Dedimania::process() - Code Metrics - Inspection of "#66 - Added Experimantal Dedimania support" - eXpansionPluginPack/eXpansion2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#329)

by De Cramer
created 2018-04-08 08:25 UTC
Dedimania::process() C

↳ Parent: Dedimania
Complexity

Conditions	16
Paths	131
Size

Total Lines	72
Code Lines	45
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	16
eloc	45
nc	131
nop	2
dl	0
loc	72
rs	5.0621
c	0
b	0
f	0
How to fix Long Method Complexity

<?php
/**
 * Created by PhpStorm.
 * User: php_r
 * Date: 27.2.2018
 * Time: 10.50
 */

namespace eXpansionExperimantal\Bundle\Dedimania\Plugins;

use eXpansionExperimantal\Bundle\Dedimania\Classes\IXR_Base64;
use eXpansionExperimantal\Bundle\Dedimania\Classes\Request;
use eXpansionExperimantal\Bundle\Dedimania\Services\DedimaniaService;
use eXpansionExperimantal\Bundle\Dedimania\Structures\DedimaniaPlayer;
use eXpansionExperimantal\Bundle\Dedimania\Structures\DedimaniaRecord;
use eXpansion\Framework\Config\Model\ConfigInterface;
use eXpansion\Framework\Core\DataProviders\Listener\ListenerInterfaceExpTimer;
use eXpansion\Framework\Core\Helpers\ChatNotification;
use eXpansion\Framework\Core\Helpers\FileSystem;
use eXpansion\Framework\Core\Helpers\Time;
use eXpansion\Framework\Core\Helpers\TMString;
use eXpansion\Framework\Core\Plugins\StatusAwarePluginInterface;
use eXpansion\Framework\Core\Services\Application\AbstractApplication;
use eXpansion\Framework\Core\Services\Console;
use eXpansion\Framework\Core\Services\DedicatedConnection\Factory;
use eXpansion\Framework\Core\Storage\Data\Player as DedicatedPlayer;
use eXpansion\Framework\Core\Storage\GameDataStorage;
use eXpansion\Framework\Core\Storage\MapStorage;
use eXpansion\Framework\Core\Storage\PlayerStorage;
use eXpansion\Framework\GameManiaplanet\DataProviders\Listener\ListenerInterfaceMpLegacyPlayer;
use eXpansion\Framework\GameManiaplanet\DataProviders\Listener\ListenerInterfaceMpScriptMap;
use eXpansion\Framework\GameManiaplanet\DataProviders\Listener\ListenerInterfaceMpScriptMatch;
use eXpansion\Framework\GameManiaplanet\ScriptMethods\GetScores;
use eXpansion\Framework\GameTrackmania\DataProviders\Listener\ListenerInterfaceRaceData;
use eXpansion\Framework\Notifications\Services\Notifications;
use Maniaplanet\DedicatedServer\Connection;
use Maniaplanet\DedicatedServer\Structures\Map;
use Maniaplanet\DedicatedServer\Structures\Player;
use Maniaplanet\DedicatedServer\Xmlrpc\Request as XmlRpcRequest;


class Dedimania implements StatusAwarePluginInterface, ListenerInterfaceExpTimer, ListenerInterfaceMpScriptMap, ListenerInterfaceMpScriptMatch, ListenerInterfaceRaceData, ListenerInterfaceMpLegacyPlayer
{
    const dedimaniaUrl = "http://dedimania.net:8081/Dedimania";

    /**
     * @var DedimaniaService
     */
    private $dedimaniaService;
    /**
     * @var ConfigInterface
     */
    private $enabled;
    /**
     * @var ConfigInterface
     */
    private $apikey;
    /**
     * @var ConfigInterface
     */
    private $serverLogin;

    private $read = [];
    private $write = [];
    private $except = [];

    /** @var \Webaccess */
    protected $webaccess;
    /**
     * @var Console
     */
    private $console;
    /** @var int */
    private $tryTimer = -1;

    /** @var int */
    private $lastUpdate;
    /** @var string|null */
    private $sessionId = null;
    private $titles;
    /**
     * @var Connection
     */
    private $connection;

    /**
     * @var GameDataStorage
     */
    private $gameDataStorage;
    /**
     * @var MapStorage
     */
    private $mapStorage;
    /**
     * @var PlayerStorage
     */
    private $playerStorage;
    /**
     * @var Notifications
     */
    private $notifications;
    /**
     * @var Time
     */
    private $time;
    /**
     * @var GetScores
     */
    private $getScores;
    /**
     * @var FileSystem
     */
    private $fileSystem;

    /** @var ChatNotification */
    private $chatNotification;

    /** @var Factory */
    private $factory;


    /**
     * Dedimania constructor.
     * @param                  $titles
     * @param ConfigInterface  $enabled
     * @param ConfigInterface  $apikey
     * @param ConfigInterface  $serverLogin
     * @param DedimaniaService $dedimaniaService
     * @param Console          $console
     * @param Factory          $connectionFactory
     * @param GameDataStorage  $gameDataStorage
     * @param MapStorage       $mapStorage
     * @param PlayerStorage    $playerStorage
     * @param Notifications    $notifications
     * @param Time             $time
     * @param GetScores        $getScores
     * @param FileSystem       $fileSystem
     * @param ChatNotification $chatNotification
     */
    public function __construct(
        $titles,
        ConfigInterface $enabled,
        ConfigInterface $apikey,
        ConfigInterface $serverLogin,
        DedimaniaService $dedimaniaService,
        Console $console,
        Factory $connectionFactory,
        GameDataStorage $gameDataStorage,
        MapStorage $mapStorage,
        PlayerStorage $playerStorage,
        Notifications $notifications,
        Time $time,
        GetScores $getScores,
        FileSystem $fileSystem,
        ChatNotification $chatNotification
    ) {
        require_once(dirname(__DIR__).DIRECTORY_SEPARATOR."Classes".DIRECTORY_SEPARATOR."Webaccess.php");
        $this->webaccess = new \Webaccess($console);
        $this->console = $console;
        $this->dedimaniaService = $dedimaniaService;
        $this->enabled = $enabled;
        $this->apikey = $apikey;
        $this->serverLogin = $serverLogin;
        $this->titles = $titles;
        $this->factory = $connectionFactory;
        $this->gameDataStorage = $gameDataStorage;
        $this->mapStorage = $mapStorage;
        $this->playerStorage = $playerStorage;
        $this->notifications = $notifications;
        $this->time = $time;
        $this->getScores = $getScores;
        $this->fileSystem = $fileSystem;
        $this->chatNotification = $chatNotification;
    }

    /**
     * Set the status of the plugin
     *
     * @param boolean $status
     *
     * @return void
     * @throws \Exception
     */
    public function setStatus($status)
    {
        if ($status && $this->enabled->get()) {
            try {
                $this->lastUpdate = time();
                $this->openSession($this->serverLogin->get(), $this->apikey->get());
            } catch (\Exception $e) {
                echo $e->getMessage();
            }
        }
    }


    /** @api */
    public function onPreLoop()
    {
        // do nothing
    }

    /** @api */
    public function onPostLoop()
    {
        try {
            if ($this->tryTimer == -1) {
                $this->webaccess->select($this->read, $this->write, $this->except, 0, 0);
            } else {
                if (time() >= $this->tryTimer) {
                    $this->console->writeln("Webaccess: Main Loop active again!");
                    $this->tryTimer = -1;
                }
            }
        } catch (\Exception $e) {
            $this->console->writeln(
                'Webaccess: OnTick Update $f00failed$555, trying to retry in 2 seconds...');
            $this->tryTimer = time() + 2;
        }
    }

    /** @api */
    public function onEverySecond()
    {
        try {
            if ($this->sessionId !== null && (time() - $this->lastUpdate) > 3 * 60) {
                $this->lastUpdate = time();
                $this->console->writeln("Dedimania: sent connection keep-alive!");
                $this->updateServerPlayers();
            }
        } catch (\Exception $e) {
            $this->console->writeln("Dedimania: periodic keep-alive failed: ".$e->getMessage());
        }
    }


    /**
     * Send a request to Dedimania
     *
     * @param Request  $request
     * @param callable $callback
     */
    final public function sendRequest(Request $request, $callback)
    {
        $this->webaccess->request(
            self::dedimaniaUrl,
            [[$this, "process"], $callback],
            $request->getXml(),
            true,
            600,
            3,
            5,
            'eXpansion server controller',
            'application/x-www-form-urlencoded; charset=UTF-8'
        );
    }

    final public function process($response, $callback)
    {

        try {

            if (is_array($response) && array_key_exists('Message', $response)) {

                $message = [];
                try {
                    if (isset($response['Message'])) {
                        $message = XmlRpcRequest::decode($response['Message']);
                    } else {
                        $this->console->writeln("Dedimania: Error received non-xmlrpc string. See dump below:");
                        $this->console->writeln(Console::error.$response);
                    }
                } catch (\Exception $ex) {
                    $this->console->writeln("Dedimania: Error received non-xmlrpc string. See dump below:");
                    $this->console->writeln(Console::error.$response['Message']);

                    return;
                }
                $errors = end($message[1]);
                $err = false;


                if (count($errors) > 0 && array_key_exists('methods', $errors[0])) {
                    $err = false;
                    foreach ($errors[0]['methods'] as $error) {
                        if (!empty($error['errors'])) {
                            $this->console->writeln('Dedimania error on method: $fff'.$error['methodName']);
                            $this->console->writeln('$f00'.$error['errors']);
                            $err = true;
                        }
                    }
                }
                if ($err) {
                    return;
                }

                $array = $message[1];
                unset($array[count($array) - 1]); // remove trailing errors and info

                if (array_key_exists("faultString", $array[0])) {
                    $this->console->writeln('Dedimania fault:$f00 '.$array[0]['faultString']);

                    return;
                }

                if (!empty($array[0][0]['Error'])) {
                    $this->console->writeln('Dedimania error:$f00 '.$array[0][0]['Error']);

                    return;
                }

                if (sizeof($array) == 1) {
                    call_user_func_array($callback, [$array[0][0]]);
                } elseif (sizeof($array) > 1) {
                    $out = [];
                    foreach ($array as $key => $value) {
                        $out[] = $value[0];
                    }
                    call_user_func_array($callback, [$out]);
                }

                return;
            } else {
                $this->console->writeln('Dedimania Error: $f00Can\'t find Message from Dedimania reply');
            }
        } catch (\Exception $e) {
            $this->console->writeln('Dedimania Error: $f00Connection to dedimania server failed.'.$e->getMessage()." trace:".$e->getTraceAsString());
        }
    }

    //#region public dedimania methods

    /**
     * @param string $serverlogin
     * @param string $apikey
     * @throws \Exception
     *
     */
    public function openSession($serverlogin, $apikey)
    {
        $this->sessionId = null;
        $server = new Player();
        $server->login = $this->gameDataStorage->getSystemInfo()->serverLogin;

        $info = $this->factory->getConnection()->getDetailedPlayerInfo($server);

        $packMask = $this->getPackMask($this->gameDataStorage->getVersion()->titleId);
        if (!$packMask) {
            throw new \Exception("Packmask not found for titleId");
        }
        $params = [
            "Game" => "TM2",
            "Login" => $serverlogin,
            "Code" => $apikey,
            "Path" => $info->path,
            "Packmask" => $packMask,
            "ServerVersion" => $this->gameDataStorage->getVersion()->version,
            "ServerBuild" => $this->gameDataStorage->getVersion()->build,
            "Tool" => "eXpansion",
            "Version" => AbstractApplication::EXPANSION_VERSION,
            "ServerIp" => $this->gameDataStorage->getSystemInfo()->publishedIp,
        ];

        $request = new Request('dedimania.OpenSession', [$params]);

        $this->sendRequest($request, function ($response) {
            $this->sessionId = $response['SessionId'];
            $this->getRecords();
            $this->connectAllPlayers();
        });
    }

    public function getRecords()
    {
        if ($this->sessionId == null) {

            return;
        }

        $map = $this->mapStorage->getCurrentMap();

        $this->dedimaniaService->setDisabled(true);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->dedimaniaService->setDedimaniaRecords([]);

        if ($map->authorTime < 6200) {
            $status = "Times under 6.2s are refused!";
            $this->console->writeln("Dedimania: Disabling records for this map. ".$status);

            return;
        }

        if ($map->nbCheckpoints < 1) {
            $status = "Checkpoints needs to be more than 1!";
            $this->console->writeln("Dedimania: Disabling records for this map. ".$status);

            return;
        }

        $params = [
            $this->sessionId,
            $this->getMapInfo(),
            $this->getGameMode(),
            $this->getServerInfo(),
            $this->getPlayers(),
        ];

        $request = new Request('dedimania.GetChallengeRecords', $params);

        $this->sendRequest($request, function ($response) {

            $this->dedimaniaService->setServerMaxRank($response['ServerMaxRank']);
            /** @var DedimaniaRecord[] $recs */
            $recs = DedimaniaRecord::fromArrayOfArray($response['Records']);

            if (isset($response['Records']['Login'])) {
                $recs = [];
                $recs[] = $response['Records'];
            }

            $this->dedimaniaService->setDedimaniaRecords($recs);

            // @todo remove when dedimania records has better frontend
            if (!empty($recs) && count($recs) > 0) {

                foreach ($this->playerStorage->getOnline() as $login => $player) {
                    $rec = $this->dedimaniaService->getRecord($login);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
                    if ($rec) {
                        $time = $this->time->timeToText($rec->best, true);
                        $this->chatNotification->sendMessage(
                            "|record|{record} Your current {variable}".$rec->rank.". {record}dedimania record {variable}|time| ".$time,
                            $login);
                    }
                }
            }
        });

    }

    public function updateServerPlayers()
    {
        if ($this->sessionId == null) {

            return;
        }

        $params = [
            $this->sessionId,
            $this->getServerInfo(),
            $this->getVotesInfo(),
            $this->getPlayers(),
        ];
        $request = new Request('dedimania.UpdateServerPlayers', $params);

        $this->sendRequest($request, function ($response) {

            // do nothing
        });

    }

    /**
     * @param DedicatedPlayer $player
     */
    public function connectPlayer(DedicatedPlayer $player)
    {
        $params = [
            $this->sessionId,
            $player->getLogin(),
            $player->getNickName(),
            $player->getPath(),
            $player->isSpectator(),
        ];

        $request = new Request('dedimania.PlayerConnect', $params);
        $this->sendRequest($request, function ($response) use ($player) {
            $dediplayer = DedimaniaPlayer::fromArray($response);

            if ($dediplayer->banned) {
                $this->chatNotification->sendMessage("|error|{error} Player {variable}".$player->getLogin()."{error} is banned from dedimania.");

                return;
            }

            $this->dedimaniaService->connectPlayer($dediplayer);


        });
    }

    /**
     * @param DedicatedPlayer $player
     */
    public function disconnectPlayer(DedicatedPlayer $player)
    {
        $params = [
            $this->sessionId,
            $player->getLogin(),
            $player->getNickName(),
            $player->getPath(),
            $player->isSpectator(),
        ];

        $request = new Request('dedimania.PlayerConnect', $params);
        $this->sendRequest($request, function ($response) use ($player) {

            $this->dedimaniaService->disconnectPlayer($player->getLogin());
        });
    }

    public function connectAllPlayers()
    {
        $players = $this->playerStorage->getOnline();

        /** @var Request $request */
        $request = null;
        foreach ($players as $x => $player) {
            $params = [
                $this->sessionId,
                $player->getLogin(),
                $player->getNickName(),
                $player->getPath(),
                $player->isSpectator(),
            ];
            if ($request === null) {
                $request = new Request('dedimania.PlayerConnect', $params);
            } else {
                $request->add('dedimania.PlayerConnect', $params);
            }
        }

        // no players to connect
        if ($request === null) {
            return;
        }

        $this->sendRequest($request, function ($response) {

            if (array_key_exists("Login", $response)) {
                $response = [0 => $response];
            }
            $this->dedimaniaService->setPlayers(DedimaniaPlayer::fromArrayOfArray($response));
        });
    }

    /*
     */

    public function setRecords()
    {
        if ($this->dedimaniaService->isDisabled()) {

            return;
        }

        $that = $this;
        $this->getScores->get(function ($scores) use ($that) {
            if (count($scores['players']) > 0 && isset($scores['players'][0]['login'])) {

                $player = new Player();
                $player->login = $scores['players'][0]['login'];
                try {
                    $replay = new IXR_Base64($this->factory->getConnection()->getValidationReplay($player));
                    $that->dedimaniaService->setVReplay($replay);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    $VReplayChecks = $scores['players'][0]['bestracecheckpoints'];

                    $times = [];
                    foreach ($scores['players'] as $player) {
                        if (count($player['bestracecheckpoints']) > 0) {
                            $times[] = [
                                "Login" => $player['login'],
                                "Best" => $player['bestracetime'],
                                "Checks" => implode(",", $player['bestracecheckpoints']),
                            ];
                        }
                    }

                    $params = [
                        $this->sessionId,
                        $this->getMapInfo(),
                        $this->getGameMode(),
                        $times,
                        $this->getReplays($scores['players'][0]['login'], $VReplayChecks),
                    ];

                    $request = new Request("dedimania.SetChallengeTimes", $params);

                    $that->sendRequest($request, function ($response) {

                        $this->console->writeln('Dedimania: $0f0records saved.');
                    });
                } catch (\Exception $e) {
                    $this->console->writeln('Dedimania: Can\'t send times, $f00'.$e->getMessage());
                }
            }

        });

    }

//endregion
//#region protected helper functions

    /**
     * @param string $top1Login
     * @param array  $bestCheckpoints
     * @return array
     */
    protected function getReplays($top1Login, $bestCheckpoints)
    {
        list($login, $GReplay) = $this->dedimaniaService->getGReplay();

        if ($GReplay != "") {
            if ($top1Login != $login) {
                $this->console->getSfStyleOutput()->warning('Fetched Ghost Replay for Dedimania differs from top 1 holders login.');
                $this->console->writeln("Trying to fetch the right new one.");
                $this->setGReplay($top1Login);
                $replay = $this->dedimaniaService->getGReplay();
                $GReplay = $replay[1];
            }
        }

        return [
            "VReplay" => $this->dedimaniaService->getVReplay(),
            "VReplayChecks" => implode(",", $bestCheckpoints),
            "Top1GReplay" => $GReplay,
        ];
    }

    /**
     * Sets new Ghost replay for the map
     * @param $login
     */
    protected function setGReplay($login)
    {
        $tempReplay = new IXR_Base64("");
        $this->dedimaniaService->setGReplay("", $tempReplay);

        $player = new Player();
        $player->login = $login;
        try {
            $this->factory->getConnection()->saveBestGhostsReplay($player, "exp2_temp_replay");
            $replay = new IXR_Base64(
                $this->fileSystem->getUserData()->readAndDelete(
                    "Replays".DIRECTORY_SEPARATOR."exp2_temp_replay.Replay.Gbx")
            );
            $this->dedimaniaService->setGReplay($login, $replay);
        } catch (\Exception $e) {
            $this->console->writeln('Dedimania: $f00Error while fetching GhostsReplay');
        }

    }

    protected function getVotesInfo()
    {
        $map = $this->mapStorage->getCurrentMap();

        return [
            "UId" => $map->uId,
            "GameMode" => $this->getGameMode(),
        ];
    }

    protected function getMapInfo()
    {
        $map = $this->factory->getConnection()->getCurrentMapInfo();

        return [
            "UId" => $map->uId,
            "Name" => $map->name,
            "Environment" => $map->environnement,
            "Author" => $map->author,
            "NbCheckpoints" => $map->nbCheckpoints,
            "NbLaps" => $map->nbLaps,
        ];
    }


    protected function getPlayers()
    {
        $players = [];
        foreach ($this->playerStorage->getPlayers() as $player) {
            $players [] = [
                "Login" => $player->getLogin(),
                "IsSpec" => $player->isSpectator(),
            ];
        }

        return $players;
    }

    protected function getServerInfo()
    {
        return [
            "SrvName" => $this->gameDataStorage->getServerOptions()->name,
            "Comment" => $this->gameDataStorage->getServerOptions()->comment ?: "",
            "Private" => $this->gameDataStorage->getServerOptions()->password ? true : false,
            "NumPlayers" => count($this->playerStorage->getPlayers()),
            "MaxPlayers" => intval($this->gameDataStorage->getServerOptions()->currentMaxPlayers),
            "NumSpecs" => count($this->playerStorage->getSpectators()),
            "MaxSpecs" => intval($this->gameDataStorage->getServerOptions()->currentMaxSpectators),
        ];
    }

    protected function getGameMode()
    {
        switch (strtolower($this->gameDataStorage->getGameInfos()->scriptName)) {

            case "timeattack.script.txt":
            case "laps.script.txt":
                return "TA";
            case "rounds.script.txt":
            case "team.script.txt":
            case "cup.script.txt":
                return "Rounds";
            default:
                return "";
        }
    }

    protected function getPackMask($titleId)
    {
        foreach ($this->titles as $title => $data) {
            if (in_array($titleId, $data)) {
                return ucfirst($title);
            }
        }

        return "";
    }

//#endregion
//#region Dedicated server callbacks

    /**
     * Callback sent when the "StartMap" section start.
     *
     * @param int     $count Each time this section is played, this number is incremented by one
     * @param int     $time Server time when the callback was sent
     * @param boolean $restarted true if the map was restarted, false otherwise
     * @param Map     $map Map started with.
     *
     * @return void
     */
    public function onStartMapStart($count, $time, $restarted, Map $map)
    {
        if (!$restarted) {
            $this->lastUpdate = time();
            $this->getRecords();
        }
    }

    /**
     * Callback sent when the "EndMap" section start.
     *
     * @param int     $count Each time this section is played, this number is incremented by one
     * @param int     $time Server time when the callback was sent
     * @param boolean $restarted true if the map was restarted, false otherwise
     * @param Map     $map Map started with.
     *
     * @return void
     */
    public function onEndMapStart($count, $time, $restarted, Map $map)
    {
        if (!$restarted) {
            $this->setRecords();
        }
    }

    /**
     * @param string $login Login of the player that crossed the CP point
     * @param int    $time Server time when the event occured,
     * @param int    $raceTime Total race time in milliseconds
     * @param int    $stuntsScore Stunts score
     * @param int    $cpInRace Number of checkpoints crossed since the beginning of the race
     * @param int[]  $curCps Checkpoints times since the beginning of the race
     * @param string $blockId Id of the checkpoint block
     * @param string $speed Speed of the player in km/h
     * @param string $distance Distance traveled by the player
     */
    public function onPlayerEndRace(
        $login,
        $time,
        $raceTime,
        $stuntsScore,
        $cpInRace,
        $curCps,
        $blockId,
        $speed,
        $distance
    ) {

        $record = $this->dedimaniaService->processRecord($login, $raceTime, $curCps);
        if ($record instanceof DedimaniaRecord) {
            $rank = $record->rank;
            if ($rank > 0) {
                if ($rank === 1) {
                    $this->setGReplay($login);
                }
                $player = $this->playerStorage->getPlayerInfo($login);
                $this->chatNotification->sendMessage("|record| {variable}$rank. {record}Dedimania Record {variable}|time| ".$this->time->timeToText($raceTime,
                        true)." {record}driven by {variable}".TMString::trimStyles($player->getNickname())); // @todo remove this when the local records handler works nicely also for dedimania
            }
        }
    }

    /**
     * Callback sent when the "StartMap" section end.
     *
     * @param int     $count Each time this section is played, this number is incremented by one
     * @param int     $time Server time when the callback was sent
     * @param boolean $restarted true if the map was restarted, false otherwise
     * @param Map     $map Map started with.
     *
     * @return void
     */
    public function onStartMapEnd($count, $time, $restarted, Map $map)
    {

    }

    /**
     * Callback sent when the "EndMatch" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndMatchStart($count, $time)
    {
        // do nothing
    }


    /**
     * Callback sent when the "EndMap" section end.
     *
     * @param int     $count Each time this section is played, this number is incremented by one
     * @param int     $time Server time when the callback was sent
     * @param boolean $restarted true if the map was restarted, false otherwise
     * @param Map     $map Map started with.
     *
     * @return void
     */
    public function onEndMapEnd($count, $time, $restarted, Map $map)
    {
        // do nothing
    }

    /**
     * Callback sent when the "StartMatch" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartMatchStart($count, $time)
    {
        // do nothing
    }

    /**
     * Callback sent when the "StartMatch" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartMatchEnd($count, $time)
    {
        // do nothing
    }


    /**
     * Callback sent when the "EndMatch" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndMatchEnd($count, $time)
    {
        // do nothing
    }

    /**
     * Callback sent when the "StartTurn" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartTurnStart($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "StartTurn" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartTurnEnd($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "EndMatch" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndTurnStart($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "EndMatch" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndTurnEnd($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "StartRound" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartRoundStart($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "StartRound" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onStartRoundEnd($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "EndMatch" section start.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndRoundStart($count, $time)
    {
        //
    }

    /**
     * Callback sent when the "EndMatch" section end.
     *
     * @param int $count Each time this section is played, this number is incremented by one
     * @param int $time Server time when the callback was sent
     *
     * @return void
     */
    public function onEndRoundEnd($count, $time)
    {
        //
    }


    /**
     * @param DedicatedPlayer $player
     * @return void
     */
    public function onPlayerConnect(DedicatedPlayer $player)
    {
        $this->connectPlayer($player);
    }

    /**
     * @param DedicatedPlayer $player
     * @param string          $disconnectionReason
     * @return void
     */
    public function onPlayerDisconnect(DedicatedPlayer $player, $disconnectionReason)
    {
        $this->disconnectPlayer($player);
    }

    /**
     * @param DedicatedPlayer $oldPlayer
     * @param DedicatedPlayer $player
     * @return void
     */
    public function onPlayerInfoChanged(
        DedicatedPlayer $oldPlayer,
        DedicatedPlayer $player
    ) {
        //
    }

    /**
     * @param DedicatedPlayer $oldPlayer
     * @param DedicatedPlayer $player
     * @return void
     */
    public function onPlayerAlliesChanged(
        DedicatedPlayer $oldPlayer,
        DedicatedPlayer $player
    ) {
        //
    }
}
eXpansionPluginPack / eXpansion2

Pull Request — master (#329)

Dedimania::process() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
