TrackManiaControl/libs/Maniaplanet/DedicatedServer/Connection.php

<?php

declare(strict_types=1);
/**
 * ManiaPlanet dedicated server Xml-RPC client
 *
 * @license     http://www.gnu.org/licenses/lgpl.html LGPL License 3
 */

namespace Maniaplanet\DedicatedServer;

/**
 * Dedicated Server Connection Instance
 * Methods returns nothing if $multicall = true
 */
class Connection
{
	const API_2011_08_01 = '2011-08-01';
	const API_2011_10_06 = '2011-10-06';
	const API_2012_06_19 = '2012-06-19';
	const API_2013_04_16 = '2013-04-16';
	const API_2022_03_21 = '2022-03-21';

	/** @var int[] */
	private static $levels = [
		null => -1,
		'User' => 0,
		'Admin' => 1,
		'SuperAdmin' => 2
	];
	/** @var Xmlrpc\GbxRemote */
	protected $xmlrpcClient;
	/** @var string */
	protected $user;
	/** @var callable[] */
	private $multicallHandlers = [];

	public function __construct(
		$host = '127.0.0.1',
		$port = 5000,
		$timeout = 5,
		$user = 'SuperAdmin',
		$password = 'SuperAdmin',
		$apiVersion = self::API_2013_04_16
	) {
		$this->xmlrpcClient = new Xmlrpc\GbxRemote($host, $port, $timeout);
		$this->authenticate($user, $password);
		$this->setApiVersion($apiVersion);
	}

	/**
	 * Allow user authentication by specifying a login and a password, to gain access to the set of functionalities corresponding to this authorization level.
	 * @param string $user
	 * @param string $password
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function authenticate($user, $password)
	{
		if (!is_string($user) || !isset(self::$levels[$user])) {
			throw new InvalidArgumentException('user = ' . print_r($user, true));
		}
		if (self::$levels[$this->user] >= self::$levels[$user]) {
			return true;
		}

		if (!is_string($password)) {
			throw new InvalidArgumentException('password = ' . print_r($password, true));
		}

		$res = $this->execute(ucfirst(__FUNCTION__), [$user, $password]);
		if ($res) {
			$this->user = $user;
		}
		return $res;
	}

	/**
	 * Add a call in queue. It will be executed by the next Call from the user to executeMulticall
	 * @param string $methodName
	 * @param mixed[] $params
	 * @param bool|callable $multicall True to queue the request or false to execute it immediately
	 * @return mixed
	 */
	public function execute($methodName, $params = [], $multicall = false)
	{
		if ($multicall) {
			$this->xmlrpcClient->addCall($methodName, $params);
			$this->multicallHandlers[] = $multicall;
		} else {
			return $this->xmlrpcClient->query($methodName, $params);
		}
	}

	/**
	 * Define the wanted api.
	 * @param string $version
	 * @param bool $multicall
	 * @return bool
	 */
	public function setApiVersion(string $version, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$version], $multicall);
	}

	/**
	 * Close the current socket connexion
	 * Never call this method, use instead DedicatedApi::delete($host, $port)
	 */
	public function terminate()
	{
		$this->xmlrpcClient->terminate();
	}

	/**
	 * Change client timeouts
	 * @param int $read read timeout (in ms), 0 to leave unchanged
	 * @param int $write write timeout (in ms), 0 to leave unchanged
	 */
	public function setTimeouts($read = null, $write = null)
	{
		$this->xmlrpcClient->setTimeouts($read, $write);
	}

	/**
	 * @return int Network idle time in seconds
	 */
	public function getIdleTime()
	{
		return $this->xmlrpcClient->getIdleTime();
	}

	/**
	 * Return pending callbacks
	 * @return mixed[]
	 */
	public function executeCallbacks()
	{
		return $this->xmlrpcClient->getCallbacks();
	}

	/**
	 * Execute the calls in queue and return the result
	 * @return mixed[]
	 */
	public function executeMulticall()
	{
		$responses = $this->xmlrpcClient->multiquery();
		foreach ($responses as $i => &$response) {
			if (!($response instanceof Xmlrpc\FaultException) && is_callable($this->multicallHandlers[$i])) {
				$response = call_user_func($this->multicallHandlers[$i], $response);
			}
		}
		$this->multicallHandlers = [];
		return $responses;
	}

	/**
	 * Change the password for the specified login/user.
	 * Only available to SuperAdmin.
	 * @param string $user
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function changeAuthPassword(string $user, string $password, $multicall = false)
	{
		if (!isset(self::$levels[$user])) {
			throw new InvalidArgumentException('user = ' . print_r($user, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$user, $password], $multicall);
	}

	/**
	 * Allow the GameServer to call you back.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 */
	public function enableCallbacks(bool $enable = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * Returns a struct with the Name, TitleId, Version, Build and ApiVersion of the application remotely controlled.
	 * @param bool $multicall
	 * @return Structures\Version
	 */
	public function getVersion($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Version'));
		}
		return Structures\Version::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @param string $struct
	 * @param bool $array
	 * @return callable
	 */
	private function structHandler($struct, $array = false)
	{
		return ['\\' . __NAMESPACE__ . '\Structures\\' . $struct, 'fromArray' . ($array ? 'OfArray' : '')];
	}

	/**
	 * Returns the current status of the server.
	 * @param bool $multicall
	 * @return Structures\Status
	 */
	public function getStatus($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Status'));
		}
		return Structures\Status::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Quit the application.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function quitGame($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Call a vote to kick a player.
	 * You can additionally supply specific parameters for this vote: a ratio, a time out and who is voting.
	 * Only available to Admin.
	 * @param mixed $player A player object or a login
	 * @param float $ratio In range [0,1] or -1 for default ratio
	 * @param int $timeout In milliseconds, 0 for default timeout, 1 for indefinite
	 * @param int $voters 0: active players, 1: any player, 2: everybody including pure spectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function callVoteKick($player, $ratio = 0.5, $timeout = 0, $voters = 1, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		$vote = new Structures\Vote(Structures\VoteRatio::COMMAND_KICK, [$login]);
		return $this->callVote($vote, $ratio, $timeout, $voters, $multicall);
	}

	/**
	 * Returns the login of the given player
	 * @param mixed $player
	 * @return string|bool
	 */
	private function getLogin($player, $allowEmpty = false)
	{
		if (is_object($player)) {
			if (property_exists($player, 'login')) {
				$player = $player->login;
			} else {
				return false;
			}
		}
		if (empty($player)) {
			return $allowEmpty ? '' : false;
		}
		if (is_string($player)) {
			return $player;
		}
		return false;
	}

	/**
	 * Call a vote for a command.
	 * You can additionally supply specific parameters for this vote: a ratio, a time out and who is voting.
	 * Only available to Admin.
	 * @param Structures\Vote $vote
	 * @param float $ratio In range [0,1] or -1 for default ratio
	 * @param int $timeout In milliseconds, 0 for default timeout, 1 for indefinite
	 * @param int $voters 0: active players, 1: any player, 2: everybody including pure spectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function callVote($vote, $ratio = -1., $timeout = 0, $voters = 1, $multicall = false)
	{
		if (!($vote instanceof Structures\Vote && $vote->isValid())) {
			throw new InvalidArgumentException('vote = ' . print_r($vote, true));
		}
		if (!Structures\VoteRatio::isRatio($ratio)) {
			throw new InvalidArgumentException('ratio = ' . print_r($ratio, true));
		}
		if (!is_int($timeout)) {
			throw new InvalidArgumentException('timeout = ' . print_r($timeout, true));
		}
		if (!is_int($voters) || $voters < 0 || $voters > 2) {
			throw new InvalidArgumentException('voters = ' . print_r($voters, true));
		}

		$xml = Xmlrpc\Request::encode($vote->cmdName, $vote->cmdParam, false);
		return $this->execute(ucfirst(__FUNCTION__) . 'Ex', [$xml, $ratio, $timeout, $voters], $multicall);
	}

	/**
	 * Call a vote to ban a player.
	 * You can additionally supply specific parameters for this vote: a ratio, a time out and who is voting.
	 * Only available to Admin.
	 * @param mixed $player A player object or a login
	 * @param float $ratio In range [0,1] or -1 for default ratio
	 * @param int $timeout In milliseconds, 0 for default timeout, 1 for indefinite
	 * @param int $voters 0: active players, 1: any player, 2: everybody including pure spectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function callVoteBan($player, $ratio = 0.6, $timeout = 0, $voters = 1, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		$vote = new Structures\Vote(Structures\VoteRatio::COMMAND_BAN, [$login]);
		return $this->callVote($vote, $ratio, $timeout, $voters, $multicall);
	}

	/**
	 * Call a vote to restart the current map.
	 * You can additionally supply specific parameters for this vote: a ratio, a time out and who is voting.
	 * Only available to Admin.
	 * @param float $ratio In range [0,1] or -1 for default ratio
	 * @param int $timeout In milliseconds, 0 for default timeout, 1 for indefinite
	 * @param int $voters 0: active players, 1: any player, 2: everybody including pure spectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function callVoteRestartMap($ratio = 0.5, $timeout = 0, $voters = 1, $multicall = false)
	{
		$vote = new Structures\Vote(Structures\VoteRatio::COMMAND_RESTART_MAP);
		return $this->callVote($vote, $ratio, $timeout, $voters, $multicall);
	}

	/**
	 * Call a vote to go to the next map.
	 * You can additionally supply specific parameters for this vote: a ratio, a time out and who is voting.
	 * Only available to Admin.
	 * @param float $ratio In range [0,1] or -1 for default ratio
	 * @param int $timeout In milliseconds, 0 for default timeout, 1 for indefinite
	 * @param int $voters 0: active players, 1: any player, 2: everybody including pure spectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function callVoteNextMap($ratio = 0.5, $timeout = 0, $voters = 1, $multicall = false)
	{
		$vote = new Structures\Vote(Structures\VoteRatio::COMMAND_NEXT_MAP);
		return $this->callVote($vote, $ratio, $timeout, $voters, $multicall);
	}

	/**
	 * Cancel the current vote.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function cancelVote($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the vote currently in progress.
	 * @param $multicall
	 * @return Structures\Vote
	 */
	public function getCurrentCallVote($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Vote'));
		}
		return Structures\Vote::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Set a new timeout for waiting for votes.
	 * Only available to Admin.
	 * @param int $timeout In milliseconds, 0 to disable votes
	 * @param bool $multicall
	 * @return bool
	 */
	public function setCallVoteTimeOut(int $timeout, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$timeout], $multicall);
	}

	/**
	 * Get the current and next timeout for waiting for votes.
	 * @param $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getCallVoteTimeOut($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new default ratio for passing a vote.
	 * Only available to Admin.
	 * @param float $ratio In range [0,1] or -1 to disable votes
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setCallVoteRatio($ratio, $multicall = false)
	{
		if (!Structures\VoteRatio::isRatio($ratio)) {
			throw new InvalidArgumentException('ratio = ' . print_r($ratio, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$ratio], $multicall);
	}

	/**
	 * Get the current default ratio for passing a vote.
	 * @param bool $multicall
	 * @return float
	 */
	public function getCallVoteRatio($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set the ratios list for passing specific votes, extended version with parameters matching.
	 * Only available to Admin.
	 * @param Structures\VoteRatio[] $ratios
	 * @param bool $replaceAll True to override the whole ratios list or false to modify only specified ratios
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setCallVoteRatios(array $ratios, bool $replaceAll = true, $multicall = false)
	{
		foreach ($ratios as $i => &$ratio) {
			if (!($ratio instanceof Structures\VoteRatio && $ratio->isValid())) {
				throw new InvalidArgumentException('ratios[' . $i . '] = ' . print_r($ratios, true));
			}
			$ratio = $ratio->toArray();
		}

		return $this->execute(ucfirst(__FUNCTION__) . 'Ex', [$replaceAll, $ratios], $multicall);
	}

	/**
	 * Get the current ratios for passing votes, extended version with parameters matching.
	 * @param bool $multicall
	 * @return Structures\VoteRatio[]
	 */
	public function getCallVoteRatios($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__) . 'Ex', [], $this->structHandler('VoteRatio', true));
		}
		return Structures\VoteRatio::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__) . 'Ex'));
	}

	/**
	 * Send a text message, possibly localised to a specific login or to everyone, without the server login.
	 * Only available to Admin.
	 * @param string|string[][] $message Single string or array of structures {Lang='xx', Text='...'}:
	 * if no matching language is found, the last text in the array is used
	 * @param mixed $recipient Login, player object or array; null for all
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function chatSendServerMessage($message, $recipient = null, $multicall = false)
	{
		$logins = $this->getLogins($recipient, true);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}

		if (is_array($message)) {
			return $this->execute(ucfirst(__FUNCTION__) . 'ToLanguage', [$message, $logins], $multicall);
		}
		if (is_string($message)) {
			if ($logins) {
				return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$message, $logins], $multicall);
			}
			return $this->execute(ucfirst(__FUNCTION__), [$message], $multicall);
		}
		// else
		throw new InvalidArgumentException('message = ' . print_r($message, true));
	}

	/**
	 * Returns logins of given players
	 * @param mixed $players
	 * @return string|bool
	 */
	private function getLogins($players, $allowEmpty = false)
	{
		if (is_array($players)) {
			$logins = [];
			foreach ($players as $player) {
				$login = $this->getLogin($player);
				if ($login === false) {
					return false;
				}
				$logins[] = $login;
			}

			return implode(',', $logins);
		}
		return $this->getLogin($players, $allowEmpty);
	}

	/**
	 * Send a text message, possibly localised to a specific login or to everyone.
	 * Only available to Admin.
	 * @param string|string[][] $message Single string or array of structures {Lang='xx', Text='...'}:
	 * if no matching language is found, the last text in the array is used
	 * @param mixed $recipient Login, player object or array; null for all
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function chatSend($message, $recipient = null, $multicall = false)
	{
		$logins = $this->getLogins($recipient, true);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}

		if (is_array($message)) {
			return $this->execute(ucfirst(__FUNCTION__) . 'ToLanguage', [$message, $logins], $multicall);
		}
		if (is_string($message)) {
			if ($logins) {
				return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$message, $logins], $multicall);
			}
			return $this->execute(ucfirst(__FUNCTION__), [$message], $multicall);
		}
		// else
		throw new InvalidArgumentException('message = ' . print_r($message, true));
	}

	/**
	 * Returns the last chat lines. Maximum of 40 lines.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string[]
	 */
	public function getChatLines($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * The chat messages are no longer dispatched to the players, they only go to the rpc callback and the controller has to manually forward them.
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $excludeServer Allows all messages from the server to be automatically forwarded.
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function chatEnableManualRouting(bool $enable = true, bool $excludeServer = false, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$enable, $excludeServer], $multicall);
	}

	/**
	 * Send a message to the specified recipient (or everybody if empty) on behalf of sender.
	 * Only available if manual routing is enabled.
	 * Only available to Admin.
	 * @param string $message
	 * @param mixed $sender Login or player object
	 * @param mixed $recipient Login, player object or array; empty for all
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function chatForward(string $message, $sender, $recipient = null, $multicall = false)
	{
		$senderLogin = $this->getLogin($sender);
		if ($senderLogin === false) {
			throw new InvalidArgumentException('sender = ' . print_r($sender, true));
		}
		$recipientLogins = $this->getLogins($recipient, true);
		if ($recipientLogins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}

		return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$message, $senderLogin, $recipientLogins], $multicall);
	}

	/**
	 * Display a notice on all clients.
	 * Only available to Admin.
	 * @param mixed $recipient Login, player object or array; empty for all
	 * @param string $message
	 * @param mixed $avatar Login or player object whose avatar will be displayed; empty for none
	 * @param int $variant 0: normal, 1: sad, 2: happy
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function sendNotice($recipient, $message, $avatar = null, $variant = 0, $multicall = false)
	{
		$logins = $this->getLogins($recipient, true);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}
		$avatarLogin = $this->getLogin($avatar, true);
		if ($avatarLogin === false) {
			throw new InvalidArgumentException('avatar = ' . print_r($avatar, true));
		}
		if (!is_int($variant) || $variant < 0 || $variant > 2) {
			throw new InvalidArgumentException('variant = ' . print_r($variant, true));
		}

		if ($logins) {
			return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$logins, $message, $avatarLogin, $variant], $multicall);
		}
		return $this->execute(ucfirst(__FUNCTION__), [$message, $avatar, $variant], $multicall);
	}

	/**
	 * Display a manialink page on all clients.
	 * Only available to Admin.
	 * @param mixed $recipient Login, player object or array; empty for all
	 * @param string $manialinks XML string
	 * @param int $timeout Seconds before autohide, 0 for permanent
	 * @param bool $hideOnClick Hide as soon as the user clicks on a page option
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function sendDisplayManialinkPage($recipient, string $manialinks, int $timeout = 0, bool $hideOnClick = false, $multicall = false)
	{
		$logins = $this->getLogins($recipient, true);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}

		if ($logins) {
			return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$logins, $manialinks, $timeout, $hideOnClick], $multicall);
		}
		return $this->execute(ucfirst(__FUNCTION__), [$manialinks, $timeout, $hideOnClick], $multicall);
	}

	/**
	 * Hide the displayed manialink page.
	 * Only available to Admin.
	 * @param mixed $recipient Login, player object or array; empty for all
	 * @param bool $multicall
	 * @return bool
	 */
	public function sendHideManialinkPage($recipient = null, $multicall = false)
	{
		$logins = $this->getLogins($recipient, true);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}

		if ($logins) {
			return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$logins], $multicall);
		}
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the latest results from the current manialink page as an array of structs {string Login, int PlayerId, int Result}:
	 * - Result == 0 -> no answer
	 * - Result > 0 -> answer from the player.
	 * @param bool $multicall
	 * @return Structures\PlayerAnswer[]
	 */
	public function getManialinkPageAnswers($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('PlayerAnswer', true));
		}
		return Structures\PlayerAnswer::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Opens a link in the client with the specified login.
	 * Only available to Admin.
	 * @param mixed $recipient Login, player object or array
	 * @param string $link URL to open
	 * @param int $linkType 0: in the external browser, 1: in the internal manialink browser
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function sendOpenLink($recipient, string $link, $linkType, $multicall = false)
	{
		$logins = $this->getLogins($recipient);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}
		if (!is_string($link)) {
			throw new InvalidArgumentException('link = ' . print_r($link, true));
		}
		if ($linkType !== 0 && $linkType !== 1) {
			throw new InvalidArgumentException('linkType = ' . print_r($linkType, true));
		}

		return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$logins, $link, $linkType], $multicall);
	}

	/**
	 * Prior to loading next map, execute SendToServer url '#qjoin=login@title'
	 * Only available to Admin.
	 * Available since ManiaPlanet 4
	 * @param	  $link
	 * @param bool $multicall
	 * @return bool
	 */
	public function sendToServerAfterMatchEnd(string $link, $multicall = false)
	{
		$link = str_replace("maniaplanet://", "", $link);

		return $this->execute(ucfirst(__FUNCTION__), [$link], $multicall);
	}

	/**
	 * Kick the player with the specified login, with an optional message.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param string $message
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function kick($player, $message = '', $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $message], $multicall);
	}

	/**
	 * Ban the player with the specified login, with an optional message.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param string $message
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function ban($player, $message = '', $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $message], $multicall);
	}

	/**
	 * Ban the player with the specified login, with a message.
	 * Add it to the black list, and optionally save the new list.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param string $message
	 * @param bool $save
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function banAndBlackList($player, string $message = '', bool $save = false, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$player, $message, $save], $multicall);
	}

	/**
	 * Unban the player with the specified login.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function unBan($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Clean the ban list of the server.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function cleanBanList($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the list of banned players.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\PlayerBan[]
	 */
	public function getBanList(int $length = -1, int $offset = 0, $multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('PlayerBan', true));
		}
		return Structures\PlayerBan::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Blacklist the player with the specified login.
	 * Only available to SuperAdmin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function blackList($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * UnBlackList the player with the specified login.
	 * Only available to SuperAdmin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function unBlackList($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Clean the blacklist of the server.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function cleanBlackList($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the list of blacklisted players.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\Player[]
	 */
	public function getBlackList(int $length = -1, int $offset = 0, $multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('Player', true));
		}
		return Structures\Player::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Load the black list file with the specified file name.
	 * Only available to Admin.
	 * @param string $filename Empty for default filename (blacklist.txt)
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function loadBlackList(string $filename = '', $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * @param string|string[] $filename
	 * @return string|string[]
	 */
	private function secureUtf8($filename)
	{
		if (is_string($filename)) {
			$filename = $this->stripBom($filename);
			if (preg_match('/[^\x09\x0A\x0D\x20-\x7E]/', $filename)) {
				return "\xEF\xBB\xBF" . $filename;
			}
			return $filename;
		}
		return array_map([$this, 'secureUtf8'], $filename);
	}

	/**
	 * @param string|string[] $str
	 * @return string|string[]
	 */
	private function stripBom($str)
	{
		if (is_string($str)) {
			return str_replace("\xEF\xBB\xBF", '', $str);
		}
		return array_map([$this, 'stripBom'], $str);
	}

	/**
	 * Save the black list in the file with specified file name.
	 * Only available to Admin.
	 * @param string $filename Empty for default filename (blacklist.txt)
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function saveBlackList(string $filename = '', $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Add the player with the specified login on the guest list.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function addGuest($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Remove the player with the specified login from the guest list.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function removeGuest($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Clean the guest list of the server.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function cleanGuestList($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the list of players on the guest list.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\Player[]
	 */
	public function getGuestList(int $length = -1, int $offset = 0, $multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('Player', true));
		}
		return Structures\Player::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Load the guest list file with the specified file name.
	 * Only available to Admin.
	 * @param string $filename Empty for default filename (guestlist.txt)
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function loadGuestList(string $filename = '', $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Save the guest list in the file with specified file name.
	 * Only available to Admin.
	 * @param string $filename Empty for default filename (guestlist.txt)
	 * @param bool $multicall
	 * @return bool
	 */
	public function saveGuestList(string $filename = '', $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Sets whether buddy notifications should be sent in the chat.
	 * Only available to Admin.
	 * @param mixed $player Login or player object; empty for global setting
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setBuddyNotification($player, bool $enable, $multicall = false)
	{
		$login = $this->getLogin($player, true);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $enable], $multicall);
	}

	/**
	 * Gets whether buddy notifications are enabled.
	 * @param mixed $player Login or player object; empty for global setting
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function getBuddyNotification($player = null, $multicall = false)
	{
		$login = $this->getLogin($player, true);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Write the data to the specified file.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param string $data
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function writeFile(string $filename, string $data, $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		$data = new Xmlrpc\Base64($data);
		return $this->execute(ucfirst(__FUNCTION__), [$filename, $data], $multicall);
	}

	/**
	 * Send the data to the specified player. Login can be a single login or a list of comma-separated logins.
	 * Only available to Admin.
	 * @param mixed $recipient Login or player object or array
	 * @param string $filename
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function tunnelSendDataFromFile($recipient, $filename, $multicall = false)
	{
		if (!file_exists($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}

		$contents = file_get_contents($filename);
		return $this->tunnelSendData($recipient, $contents, $multicall);
	}

	/**
	 * Send the data to the specified player. Login can be a single login or a list of comma-separated logins.
	 * Only available to Admin.
	 * @param mixed $recipient Login, player object or array
	 * @param string $data
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function tunnelSendData($recipient, $data, $multicall = false)
	{
		$logins = $this->getLogins($recipient);
		if ($logins === false) {
			throw new InvalidArgumentException('recipient = ' . print_r($recipient, true));
		}
		if (!is_string($data)) {
			throw new InvalidArgumentException('data = ' . print_r($data, true));
		}

		$data = new Xmlrpc\Base64($data);
		return $this->execute(ucfirst(__FUNCTION__) . 'ToLogin', [$logins, $data], $multicall);
	}

	/**
	 * Just log the parameters and invoke a callback.
	 * Can be used to talk to other xmlrpc clients connected, or to make custom votes.
	 * If used in a callvote, the first parameter will be used as the vote message on the clients.
	 * Only available to Admin.
	 * @param string $message
	 * @param string $callback
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function dedicatedEcho($message, $callback = '', $multicall = false)
	{
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}
		if (!is_string($callback)) {
			throw new InvalidArgumentException('callback = ' . print_r($callback, true));
		}

		return $this->execute('Echo', [$message, $callback], $multicall);
	}

	/**
	 * Ignore the player with the specified login.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function ignore($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Unignore the player with the specified login.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function unIgnore($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Clean the ignore list of the server.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function cleanIgnoreList($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the list of ignored players.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\Player[]
	 * @throws InvalidArgumentException
	 */
	public function getIgnoreList($length = -1, $offset = 0, $multicall = false)
	{
		if (!is_int($length)) {
			throw new InvalidArgumentException('length = ' . print_r($length, true));
		}
		if (!is_int($offset)) {
			throw new InvalidArgumentException('offset = ' . print_r($offset, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('Player', true));
		}
		return Structures\Player::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Pay planets from the server account to a player.
	 * The creation of the transaction itself may cost planets, so you need to have planets on the server account.
	 * Only available to Admin.
	 * @param mixed $payee Login or player object
	 * @param int $amount
	 * @param string $message
	 * @param bool $multicall
	 * @return int BillId
	 * @throws InvalidArgumentException
	 */
	public function pay($payee, $amount, $message = '', $multicall = false)
	{
		$login = $this->getLogin($payee);
		if ($login === false) {
			throw new InvalidArgumentException('payee = ' . print_r($payee, true));
		}
		if (!is_int($amount) || $amount < 1) {
			throw new InvalidArgumentException('amount = ' . print_r($amount, true));
		}
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $amount, $message], $multicall);
	}

	/**
	 * Create a bill, send it to a player, and return the BillId.
	 * The creation of the transaction itself may cost planets, so you need to have planets on the server account.
	 * Only available to Admin.
	 * @param mixed $payer Login or player object
	 * @param int $amount
	 * @param string $message
	 * @param mixed $payee Login or player object; empty for server account
	 * @param bool $multicall
	 * @return int BillId
	 * @throws InvalidArgumentException
	 */
	public function sendBill($payer, $amount, $message = '', $payee = null, $multicall = false)
	{
		$payerLogin = $this->getLogin($payer);
		if ($payerLogin === false) {
			throw new InvalidArgumentException('payer = ' . print_r($payer, true));
		}
		if (!is_int($amount) || $amount < 1) {
			throw new InvalidArgumentException('amount = ' . print_r($amount, true));
		}
		if (!is_string($message)) {
			throw new InvalidArgumentException('message = ' . print_r($message, true));
		}
		$payeeLogin = $this->getLogin($payee, true);
		if ($payeeLogin === false) {
			throw new InvalidArgumentException('payee = ' . print_r($payee, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$payerLogin, $amount, $message, $payeeLogin], $multicall);
	}

	/**
	 * Returns the current state of a bill.
	 * @param int $billId
	 * @param bool $multicall
	 * @return Structures\Bill
	 * @throws InvalidArgumentException
	 */
	public function getBillState($billId, $multicall = false)
	{
		if (!is_int($billId)) {
			throw new InvalidArgumentException('billId = ' . print_r($billId, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$billId], $this->structHandler('Bill'));
		}
		return Structures\Bill::fromArray($this->execute(ucfirst(__FUNCTION__), [$billId]));
	}

	/**
	 * Returns the current number of planets on the server account.
	 * @param bool $multicall
	 * @return int
	 */
	public function getServerPlanets($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Get some system infos, including connection rates (in kbps).
	 * @param bool $multicall
	 * @return Structures\SystemInfos
	 */
	public function getSystemInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('SystemInfos'));
		}
		return Structures\SystemInfos::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Set the download and upload rates (in kbps).
	 * @param int $downloadRate
	 * @param int $uploadRate
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setConnectionRates($downloadRate, $uploadRate, $multicall = false)
	{
		if (!is_int($downloadRate)) {
			throw new InvalidArgumentException('downloadRate = ' . print_r($downloadRate, true));
		}
		if (!is_int($uploadRate)) {
			throw new InvalidArgumentException('uploadRate = ' . print_r($uploadRate, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$downloadRate, $uploadRate], $multicall);
	}

	/**
	 * Returns the list of tags and associated values set on this server.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return Structures\Tag[]
	 */
	public function getServerTags($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Tag', true));
		}
		return Structures\Tag::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Set a tag and its value on the server.
	 * Only available to Admin.
	 * @param string $key
	 * @param string $value
	 * @param bool $multicall
	 * @return bool
	 */
	public function setServerTag(string $key, string $value, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$key, $value], $multicall);
	}

	/**
	 * Unset the tag with the specified name on the server.
	 * Only available to Admin.
	 * @param string $key
	 * @param bool $multicall
	 * @return bool
	 */
	public function unsetServerTag(string $key, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$key], $multicall);
	}

	/**
	 * Reset all tags on the server.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function resetServerTags($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new server name in utf8 format.
	 * Only available to Admin.
	 * @param string $name
	 * @param bool $multicall
	 * @return bool
	 */
	public function setServerName(string $name, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$name], $multicall);
	}

	/**
	 * Get the server name in utf8 format.
	 * @param bool $multicall
	 * @return string
	 */
	public function getServerName($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new server comment in utf8 format.
	 * Only available to Admin.
	 * @param string $comment
	 * @param bool $multicall
	 * @return bool
	 */
	public function setServerComment(string $comment, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$comment], $multicall);
	}

	/**
	 * Get the server comment in utf8 format.
	 * @param bool $multicall
	 * @return string
	 */
	public function getServerComment($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set whether the server should be hidden from the public server list.
	 * Only available to Admin.
	 * @param int $visibility 0: visible, 1: always hidden, 2: hidden from nations
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setHideServer($visibility, $multicall = false)
	{
		if (!is_int($visibility) || $visibility < 0 || $visibility > 2) {
			throw new InvalidArgumentException('visibility = ' . print_r($visibility, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$visibility], $multicall);
	}

	/**
	 * Get whether the server wants to be hidden from the public server list.
	 * @param bool $multicall
	 * @return int
	 */
	public function getHideServer($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns true if this is a relay server.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isRelayServer($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new password for the server.
	 * Only available to Admin.
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 */
	public function setServerPassword(string $password, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$password], $multicall);
	}

	/**
	 * Get the server password if called as Admin or Super Admin, else returns if a password is needed or not.
	 * @param bool $multicall
	 * @return string|bool
	 */
	public function getServerPassword($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new password for the spectator mode.
	 * Only available to Admin.
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setServerPasswordForSpectator(string $password, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$password], $multicall);
	}

	/**
	 * Get the password for spectator mode if called as Admin or Super Admin, else returns if a password is needed or not.
	 * @param bool $multicall
	 * @return string|bool
	 */
	public function getServerPasswordForSpectator($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new maximum number of players.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $maxPlayers
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setMaxPlayers(int $maxPlayers, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$maxPlayers], $multicall);
	}

	/**
	 * Get the current and next maximum number of players allowed on server.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getMaxPlayers($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new maximum number of spectators.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $maxSpectators
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setMaxSpectators(int $maxSpectators, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$maxSpectators], $multicall);
	}

	/**
	 * Get the current and next maximum number of Spectators allowed on server.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getMaxSpectators($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Declare if the server is a lobby, the number and maximum number of players currently managed by it, and the average level of the players.
	 * Only available to Admin.
	 * @param bool $isLobby
	 * @param int $currentPlayers
	 * @param int $maxPlayers
	 * @param float $averageLevel
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setLobbyInfo($isLobby, $currentPlayers, $maxPlayers, $averageLevel, $multicall = false)
	{
		if (!is_bool($isLobby)) {
			throw new InvalidArgumentException('isLobby = ' . print_r($isLobby, true));
		}
		if (!is_int($currentPlayers)) {
			throw new InvalidArgumentException('currentPlayers = ' . print_r($currentPlayers, true));
		}
		if (!is_int($maxPlayers)) {
			throw new InvalidArgumentException('maxPlayers = ' . print_r($maxPlayers, true));
		}
		if (!is_float($averageLevel)) {
			throw new InvalidArgumentException('averageLevel = ' . print_r($averageLevel, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$isLobby, $currentPlayers, $maxPlayers, $averageLevel], $multicall);
	}

	/**
	 * Get whether the server if a lobby, the number and maximum number of players currently managed by it.
	 * @param bool $multicall
	 * @return Structures\LobbyInfo
	 */
	public function getLobbyInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('LobbyInfo'));
		}
		return Structures\LobbyInfo::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Customize the clients 'leave server' dialog box.
	 * Only available to Admin.
	 * @param string $manialink
	 * @param string $sendToServer Server URL, eg. '#qjoin=login@title'
	 * @param bool $askFavorite
	 * @param int $quitButtonDelay In milliseconds
	 * @param bool $multicall
	 * @return bool
	 */
	public function customizeQuitDialog(string $manialink, string $sendToServer = '', bool $askFavorite = true, int $quitButtonDelay = 0, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$manialink, $sendToServer, $askFavorite, $quitButtonDelay], $multicall);
	}

	/**
	 * Set whether, when a player is switching to spectator, the server should still consider him a player and keep his player slot, or not.
	 * Only available to Admin.
	 * @param bool $keep
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function keepPlayerSlots(bool $keep = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$keep], $multicall);
	}

	/**
	 * Get whether the server keeps player slots when switching to spectator.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isKeepingPlayerSlots($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Enable or disable peer-to-peer upload from server.
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 */
	public function enableP2PUpload(bool $enable = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns if the peer-to-peer upload from server is enabled.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isP2PUpload($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Enable or disable peer-to-peer download for server.
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function enableP2PDownload($enable = true, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns if the peer-to-peer download for server is enabled.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isP2PDownload($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Allow clients to download maps from the server.
	 * Only available to Admin.
	 * @param bool $allow
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function allowMapDownload($allow = true, $multicall = false)
	{
		if (!is_bool($allow)) {
			throw new InvalidArgumentException('allow = ' . print_r($allow, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$allow], $multicall);
	}

	/**
	 * Returns if clients can download maps from the server.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isMapDownloadAllowed($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the path of the game datas directory.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function gameDataDirectory($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], [$this, 'stripBom']);
		}
		return $this->stripBom($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns the path of the maps directory.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function getMapsDirectory($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], [$this, 'stripBom']);
		}
		return $this->stripBom($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns the path of the skins directory.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function getSkinsDirectory($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], [$this, 'stripBom']);
		}
		return $this->stripBom($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2013-04-11
	 * Set Team names and colors.
	 * Only available to Admin.
	 * @param string $name1
	 * @param float $color1
	 * @param string $path1
	 * @param string $name2
	 * @param float $color2
	 * @param string $path2
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setTeamInfo($name1, $color1, $path1, $name2, $color2, $path2, $multicall=false)
	{
		if(!is_string($name1))
			throw new InvalidArgumentException('name1 = '.print_r($name1, true));
		if(!is_float($color1))
			throw new InvalidArgumentException('color1 = '.print_r($color1, true));
		if(!is_string($path1))
			throw new InvalidArgumentException('path1 = '.print_r($path1, true));
		if(!is_string($name2))
			throw new InvalidArgumentException('name2 = '.print_r($name2, true));
		if(!is_float($color2))
			throw new InvalidArgumentException('color2 = '.print_r($color2, true));
		if(!is_string($path2))
			throw new InvalidArgumentException('path2 = '.print_r($path2, true));

		return $this->execute(ucfirst(__FUNCTION__), array('unused', 0., 'World', $name1, $color1, $path1, $name2, $color2, $path2), $multicall);
	}

	/**
	 * Return info for a given team.
	 * Only available to Admin.
	 * @param int $team 0: no clan, 1 or 2
	 * @param bool $multicall
	 * @return Structures\Team
	 * @throws InvalidArgumentException
	 */
	public function getTeamInfo($team, $multicall = false)
	{
		if (!is_int($team) || $team < 0 || $team > 2) {
			throw new InvalidArgumentException('team = ' . print_r($team, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$team], $this->structHandler('Team'));
		}
		return Structures\Team::fromArray($this->execute(ucfirst(__FUNCTION__), [$team]));
	}

	/**
	 * Set the clublinks to use for the two teams.
	 * Only available to Admin.
	 * @param string $team1
	 * @param string $team2
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForcedClubLinks(string $team1, string $team2, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$team1, $team2], $multicall);
	}

	/**
	 * Get the forced clublinks.
	 * @param bool $multicall
	 * @return string[]
	 */
	public function getForcedClubLinks($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * (debug tool) Connect a fake player to the server and returns the login.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function connectFakePlayer($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * (debug tool) Disconnect a fake player.
	 * Only available to Admin.
	 * @param string $login Fake player login or '*' for all
	 * @param bool $multicall
	 * @return bool
	 */
	public function disconnectFakePlayer(string $login, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * Returns the token infos for a player.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return Structures\TokenInfos
	 * @throws InvalidArgumentException
	 */
	public function getDemoTokenInfosForPlayer($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$login], $this->structHandler('TokenInfos'));
		}
		return Structures\TokenInfos::fromArray($this->execute(ucfirst(__FUNCTION__), [$login]));
	}

	/**
	 * Disable player horns.
	 * Only available to Admin.
	 * @param bool $disable
	 * @param bool $multicall
	 * @return bool
	 */
	public function disableHorns(bool $disable = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$disable], $multicall);
	}

	/**
	 * Returns whether the horns are disabled.
	 * @param bool $multicall
	 * @return bool
	 */
	public function areHornsDisabled($multicall = false): bool
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Disable the automatic mesages when a player connects/disconnects from the server.
	 * Only available to Admin.
	 * @param bool $disable
	 * @param bool $multicall
	 * @return bool
	 */
	public function disableServiceAnnounces(bool $disable = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$disable], $multicall);
	}

	/**
	 * Returns whether the automatic mesages are disabled.
	 * @param bool $multicall
	 * @return bool
	 */
	public function areServiceAnnouncesDisabled($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Enable the autosaving of all replays (vizualisable replays with all players, but not validable) on the server.
	 * Only available to SuperAdmin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function autoSaveReplays(bool $enable = true, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Enable the autosaving on the server of validation replays, every time a player makes a new time.
	 * Only available to SuperAdmin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function autoSaveValidationReplays($enable = true, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * Returns if autosaving of all replays is enabled on the server.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isAutoSaveReplaysEnabled($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns if autosaving of validation replays is enabled on the server.
	 * @param bool $multicall
	 * @return bool
	 */
	public function isAutoSaveValidationReplaysEnabled($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Saves the current replay (vizualisable replays with all players, but not validable).
	 * Only available to Admin.
	 * @param string $filename Empty for automatic filename
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function saveCurrentReplay(string $filename = '', $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Saves a replay with the ghost of all the players' best race.
	 * Only available to Admin.
	 * @param mixed $player Login or player object; empty for all
	 * @param string $filename Empty for automatic filename
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function saveBestGhostsReplay($player = null, string $filename = '', $multicall = false)
	{
		$login = $this->getLogin($player, true);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$login, $filename], $multicall);
	}

	/**
	 * Returns a replay containing the data needed to validate the current best time of the player.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return string
	 * @throws InvalidArgumentException
	 */
	public function getValidationReplay($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$login], function ($v) {
				return $v->scalar;
			});
		}
		return $this->execute(ucfirst(__FUNCTION__), [$login])->scalar;
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new ladder mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $mode 0: disabled, 1: forced
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setLadderMode($mode, $multicall = false)
	{
		if ($mode !== 0 && $mode !== 1) {
			throw new InvalidArgumentException('mode = ' . print_r($mode, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$mode], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next ladder mode on server.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getLadderMode($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the ladder points limit for the players allowed on this server.
	 * @param bool $multicall
	 * @return Structures\LadderLimits
	 */
	public function getLadderServerLimits($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('LadderLimits'));
		}
		return Structures\LadderLimits::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set the network vehicle quality.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $quality 0: fast, 1: high
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setVehicleNetQuality($quality, $multicall = false)
	{
		if ($quality !== 0 && $quality !== 1) {
			throw new InvalidArgumentException('quality = ' . print_r($quality, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$quality], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next network vehicle quality on server.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getVehicleNetQuality($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set new server options using the struct passed as parameters.
	 * Mandatory fields:
	 *  Name, Comment, Password, PasswordForSpectator, NextCallVoteTimeOut and CallVoteRatio.
	 * Ignored fields:
	 *  LadderServerLimitMin, LadderServerLimitMax and those starting with Current.
	 * All other fields are optional and can be set to null to be ignored.
	 * Only available to Admin.
	 * A change of any field starting with Next requires a map restart to be taken into account.
	 * @param Structures\ServerOptions $options
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setServerOptions(\Structures\ServerOptions $options, $multicall = false)
	{
		if ($options->isValid() === false) {
			throw new InvalidArgumentException('options = ' . print_r($options, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$options->toSetterArray()], $multicall);
	}

	/**
	 * Returns a struct containing the server options
	 * @param bool $multicall
	 * @return Structures\ServerOptions
	 */
	public function getServerOptions($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('ServerOptions'));
		}
		return Structures\ServerOptions::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Set whether the players can choose their side or if the teams are forced by the server (using ForcePlayerTeam()).
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForcedTeams($enable, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * Returns whether the players can choose their side or if the teams are forced by the server.
	 * @param bool $multicall
	 * @return bool
	 */
	public function getForcedTeams($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Defines the packmask of the server.
	 * Only maps matching the packmask will be allowed on the server, so that player connecting to it know what to expect.
	 * Only available when the server is stopped.
	 * Only available in 2011-08-01 API version.
	 * Only available to Admin.
	 * @param string $packMask
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setServerPackMask($packMask, $multicall = false)
	{
		if (!is_string($packMask)) {
			throw new InvalidArgumentException('packMask = ' . print_r($packMask, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$packMask], $multicall);
	}

	/**
	 * Get the packmask of the server.
	 * Only available in 2011-08-01 API version.
	 * @param bool $multicall
	 * @return string
	 */
	public function getServerPackMask($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set the mods to apply on the clients.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $override If true, even the maps with a mod will be overridden by the server setting
	 * @param Structures\Mod|Structures\Mod[] $mods Array of structures [{string Env, string Url}, ...]
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForcedMods($override, $mods, $multicall = false)
	{
		if (!is_bool($override)) {
			throw new InvalidArgumentException('override = ' . print_r($override, true));
		}
		if (is_array($mods)) {
			foreach ($mods as $i => &$mod) {
				if (!($mod instanceof Structures\Mod)) {
					throw new InvalidArgumentException('mods[' . $i . '] = ' . print_r($mod, true));
				}
				$mod = $mod->toArray();
			}
		} elseif ($mods instanceof Structures\Mod) {
			$mods = [$mods->toArray()];
		} else {
			throw new InvalidArgumentException('mods = ' . print_r($mods, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$override, $mods], $multicall);
	}

	/**
	 * Get the mods settings.
	 * @param bool $multicall
	 * @return array {bool Override, Structures\Mod[] Mods}
	 */
	public function getForcedMods($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], function ($v) {
				$v['Mods'] = Structures\Mod::fromArrayOfArray($v['Mods']);
				return $v;
			});
		}
		$result = $this->execute(ucfirst(__FUNCTION__));
		$result['Mods'] = Structures\Mod::fromArrayOfArray($result['Mods']);
		return $result;
	}

	/**
	 * Set the music to play on the clients.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $override If true, even the maps with a custom music will be overridden by the server setting
	 * @param string $music Url or filename relative to the GameData path
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForcedMusic(bool $override, string $music, $multicall = false)
	{
		if (!preg_match('~^.+?://~', $music)) {
			$music = $this->secureUtf8($music);
		}

		return $this->execute(ucfirst(__FUNCTION__), [$override, $music], $multicall);
	}

	/**
	 * Get the music setting.
	 * @param bool $multicall
	 * @return Structures\Music
	 */
	public function getForcedMusic($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Music'));
		}
		return Structures\Music::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Defines a list of remappings for player skins.
	 * Will only affect players connecting after the value is set.
	 * Only available to Admin.
	 * @param Structures\ForcedSkin|Structures\ForcedSkin[] $skins List of structs {Orig, Name, Checksum, Url}:
	 * - Orig is the name of the skin to remap, or '*' for any other
	 * - Name, Checksum, Url define the skin to use (you may set value '' for any of those, all 3 null means same as Orig).
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForcedSkins($skins, $multicall = false)
	{
		if (is_array($skins)) {
			foreach ($skins as $i => &$skin) {
				if (!($skin instanceof Structures\ForcedSkin)) {
					throw new InvalidArgumentException('skins[' . $i . '] = ' . print_r($skin, true));
				}
				$skin = $skin->toArray();
			}
		} elseif ($skins instanceof Structures\ForcedSkin) {
			$skins = [$skins->toArray()];
		} else {
			throw new InvalidArgumentException('skins = ' . print_r($skins, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$skins], $multicall);
	}

	/**
	 * Get the current forced skins.
	 * @param bool $multicall
	 * @return Structures\ForcedSkin[]
	 */
	public function getForcedSkins($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('ForcedSkin', true));
		}
		return Structures\ForcedSkin::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns the last error message for an internet connection.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function getLastConnectionErrorMessage($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new password for the referee mode.
	 * Only available to Admin.
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setRefereePassword(string $password, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$password], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the password for referee mode if called as Admin or Super Admin, else returns if a password is needed or not.
	 * @param bool $multicall
	 * @return string|bool
	 */
	public function getRefereePassword($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set the referee validation mode.
	 * Only available to Admin.
	 * @param int $mode 0: validate the top3 players, 1: validate all players
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setRefereeMode($mode, $multicall = false)
	{
		if ($mode !== 0 && $mode !== 1) {
			throw new InvalidArgumentException('mode = ' . print_r($mode, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$mode], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the referee validation mode.
	 * @param bool $multicall
	 * @return int
	 */
	public function getRefereeMode($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set whether the game should use a variable validation seed or not.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setUseChangingValidationSeed($enable, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next value of UseChangingValidationSeed.
	 * @param bool $multicall
	 * @return bool[] {bool CurrentValue, bool NextValue}
	 */
	public function getUseChangingValidationSeed($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set the maximum time the server must wait for inputs from the clients before dropping data, or '0' for auto-adaptation.
	 * Only used by ShootMania.
	 * Only available to Admin.
	 * @param int $latency
	 * @param bool $multicall
	 * @return bool
	 */
	public function setClientInputsMaxLatency(int $latency, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$latency], $multicall);
	}

	/**
	 * Get the current ClientInputsMaxLatency.
	 * Only used by ShootMania.
	 * @param bool $multicall
	 * @return int
	 */
	public function getClientInputsMaxLatency($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Sets whether the server is in warm-up phase or not.
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setWarmUp($enable, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns whether the server is in warm-up phase.
	 * @param bool $multicall
	 * @return bool
	 */
	public function getWarmUp($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Get the current mode script.
	 * @param bool $multicall
	 * @return string
	 */
	public function getModeScriptText($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set the mode script and restart.
	 * Only available to Admin.
	 * @param string $script
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setModeScriptText($script, $multicall = false)
	{
		if (!is_string($script)) {
			throw new InvalidArgumentException('script = ' . print_r($script, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$script], $multicall);
	}

	/**
	 * Returns the description of the current mode script.
	 * @param bool $multicall
	 * @return Structures\ScriptInfo
	 */
	public function getModeScriptInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('ScriptInfo'));
		}
		return Structures\ScriptInfo::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns the current settings of the mode script.
	 * @param bool $multicall
	 * @return array {mixed <setting name>, ...}
	 */
	public function getModeScriptSettings($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Change the settings of the mode script.
	 * Only available to Admin.
	 * @param mixed[] $settings {mixed <setting name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setModeScriptSettings($settings, $multicall = false)
	{
		if (!is_array($settings) || !$settings) {
			throw new InvalidArgumentException('settings = ' . print_r($settings, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$settings], $multicall);
	}

	/**
	 * Send commands to the mode script.
	 * Only available to Admin.
	 * @param mixed[] $commands {mixed <command name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function sendModeScriptCommands($commands, $multicall = false)
	{
		if (!is_array($commands) || !$commands) {
			throw new InvalidArgumentException('commands = ' . print_r($commands, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$commands], $multicall);
	}

	/**
	 * Change the settings and send commands to the mode script.
	 * Only available to Admin.
	 * @param mixed[] $settings {mixed <setting name>, ...}
	 * @param mixed[] $commands {mixed <command name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setModeScriptSettingsAndCommands($settings, $commands, $multicall = false)
	{
		if (!is_array($settings) || !$settings) {
			throw new InvalidArgumentException('settings = ' . print_r($settings, true));
		}
		if (!is_array($commands) || !$commands) {
			throw new InvalidArgumentException('commands = ' . print_r($commands, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$settings, $commands], $multicall);
	}

	/**
	 * Returns the current xml-rpc variables of the mode script.
	 * @param bool $multicall
	 * @return array {mixed <variable name>, ...}
	 */
	public function getModeScriptVariables($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set the xml-rpc variables of the mode script.
	 * Only available to Admin.
	 * @param mixed[] $variables {mixed <variable name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setModeScriptVariables($variables, $multicall = false)
	{
		if (!is_array($variables) || !$variables) {
			throw new InvalidArgumentException('variables = ' . print_r($variables, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$variables], $multicall);
	}

	/**
	 * Send an event to the mode script.
	 * Only available to Admin.
	 * @param string $event
	 * @param string|string[] $params
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function triggerModeScriptEvent(string $event, $params = '', $multicall = false)
	{
		if (is_string($params)) {
			return $this->execute(ucfirst(__FUNCTION__), [$event, $params], $multicall);
		}

		if (is_array($params)) {
			foreach ($params as $param) {
				if (!is_string($param)) {
					throw new InvalidArgumentException('argument must be a string: param = ' . print_r($param, true));
				}
			}
			return $this->execute(ucfirst(__FUNCTION__) . 'Array', [$event, $params], $multicall);
		}

		// else
		throw new InvalidArgumentException('argument must be string or string[]: params = ' . print_r($params, true));
	}

	/**
	 * Set the ServerPlugin settings.
	 * Only available to Admin.
	 * @param boolean $forceReload
	 * @param string $filename
	 * @param array $settings
	 * @param bool $multicall
	 * @return bool
	 */
	function setServerPlugin($forceReload, $filename='', $settings=array(), $multicall=false)
	{
		if (count($settings) === 0)
			return $this->execute(ucfirst(__FUNCTION__), array($forceReload, $filename), $multicall);

		return $this->execute(ucfirst(__FUNCTION__), array($forceReload, $filename, $settings), $multicall);
	}

	/**
	 * Get the ServerPlugin current settings.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	function getServerPlugin($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * Returns the current xml-rpc variables of the server script.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	function getServerPluginVariables($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * Set the xml-rpc variables of the server script.
	 * Only available to Admin.
	 * @param mixed[] $variables {mixed <variable name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setServerPluginVariables($variables, $multicall=false)
	{
		if(!is_array($variables) || !$variables)
			throw new InvalidArgumentException('variables = '.print_r($variables, true));

		return $this->execute(ucfirst(__FUNCTION__), array($variables), $multicall);
	}

	/**
	 * Send an event to the server script.
	 * Only available to Admin.
	 * @param string $event
	 * @param string|string[] $params
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function triggerServerPluginEvent($event, $params='', $multicall=false)
	{
		if(!is_string($event))
			throw new InvalidArgumentException('event name must be a string: event = '.print_r($event, true));

		if(is_string($params))
			return $this->execute(ucfirst(__FUNCTION__), array($event, $params), $multicall);

		if(is_array($params)){
			foreach($params as $param){
				if(!is_string($param)){
					throw new InvalidArgumentException('argument must be a string: param = '.print_r($param, true));
				}
			}
			return $this->execute(ucfirst(__FUNCTION__).'Array', array($event, $params), $multicall);
		}

		// else
		throw new InvalidArgumentException('argument must be string or string[]: params = '.print_r($params, true));
	}

	/**
	 * Get the script cloud variables of given object.
	 * Only available to Admin.
	 * @param string $type
	 * @param string $id
	 * @param bool $multicall
	 * @return array {mixed <variable name>, ...}
	 * @throws InvalidArgumentException
	 */
	public function getScriptCloudVariables($type, $id, $multicall = false)
	{
		if (!is_string($type)) {
			throw new InvalidArgumentException('type = ' . print_r($type, true));
		}
		if (!is_string($id)) {
			throw new InvalidArgumentException('id = ' . print_r($id, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$type, $id], $multicall);
	}

	/**
	 * Set the script cloud variables of given object.
	 * Only available to Admin.
	 * @param string $type
	 * @param string $id
	 * @param mixed[] $variables {mixed <variable name>, ...}
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setScriptCloudVariables($type, $id, $variables, $multicall = false)
	{
		if (!is_string($type)) {
			throw new InvalidArgumentException('type = ' . print_r($type, true));
		}
		if (!is_string($id)) {
			throw new InvalidArgumentException('id = ' . print_r($id, true));
		}
		if (!is_array($variables) || !$variables) {
			throw new InvalidArgumentException('variables = ' . print_r($variables, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$type, $id, $variables], $multicall);
	}

	/**
	 * Restarts the map.
	 * Only available to Admin.
	 * @param bool $dontClearCupScores Only available in legacy cup mode
	 * @param bool $multicall
	 * @return bool
	 */
	public function restartMap($dontClearCupScores = false, $multicall = false)
	{
		if (!is_bool($dontClearCupScores)) {
			throw new InvalidArgumentException('dontClearCupScores = ' . print_r($dontClearCupScores, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$dontClearCupScores], $multicall);
	}

	/**
	 * Switch to next map.
	 * Only available to Admin.
	 * @param bool $dontClearCupScores Only available in legacy cup mode
	 * @param bool $multicall
	 * @return bool
	 */
	public function nextMap($dontClearCupScores = false, $multicall = false)
	{
		if (!is_bool($dontClearCupScores)) {
			throw new InvalidArgumentException('dontClearCupScores = ' . print_r($dontClearCupScores, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$dontClearCupScores], $multicall);
	}

	/**
	 * Attempt to balance teams.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function autoTeamBalance($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Stop the server.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function stopServer($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * In legacy Rounds or Laps mode, force the end of round without waiting for all players to giveup/finish.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function forceEndRound($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set new game settings using the struct passed as parameters.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param Structures\GameInfos $gameInfos
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setGameInfos($gameInfos, $multicall = false)
	{
		if (!($gameInfos instanceof Structures\GameInfos)) {
			throw new InvalidArgumentException('gameInfos = ' . print_r($gameInfos, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$gameInfos->toArray()], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns a struct containing the current game settings.
	 * @param bool $multicall
	 * @return Structures\GameInfos
	 */
	public function getCurrentGameInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('GameInfos'));
		}
		return Structures\GameInfos::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns a struct containing the game settings for the next map.
	 * @param bool $multicall
	 * @return Structures\GameInfos
	 */
	public function getNextGameInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('GameInfos'));
		}
		return Structures\GameInfos::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns a struct containing two other structures, the first containing the current game settings and the second the game settings for next map.
	 * @param bool $multicall
	 * @return Structures\GameInfos[] {Structures\GameInfos CurrentGameInfos, Structures\GameInfos NextGameInfos}
	 */
	public function getGameInfos($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('GameInfos', true));
		}
		return Structures\GameInfos::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new game mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $gameMode 0: Script, 1: Rounds, 2: TimeAttack, 3: Team, 4: Laps, 5: Cup, 6: Stunt
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setGameMode($gameMode, $multicall = false)
	{
		if (!is_int($gameMode) || $gameMode < 0 || $gameMode > 6) {
			throw new InvalidArgumentException('gameMode = ' . print_r($gameMode, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$gameMode], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current game mode.
	 * @param bool $multicall
	 * @return int
	 */
	public function getGameMode($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new chat time value (actually the duration of the podium).
	 * Only available to Admin.
	 * @param int $chatTime In milliseconds, 0: no podium displayed
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setChatTime($chatTime, $multicall = false)
	{
		if (!is_int($chatTime)) {
			throw new InvalidArgumentException('chatTime = ' . print_r($chatTime, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$chatTime], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next chat time.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getChatTime($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new finish timeout value for legacy laps and rounds based modes.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $timeout In milliseconds, 0: default, 1: adaptative to the map duration
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setFinishTimeout($timeout, $multicall = false)
	{
		if (!is_int($timeout)) {
			throw new InvalidArgumentException('timeout = ' . print_r($timeout, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$timeout], $multicall);
	}

	/**
	 * Get the current and next FinishTimeout.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getFinishTimeout($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set whether to enable the automatic warm-up phase in all modes.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $duration 0: disable, number of rounds in rounds based modes, number of times the gold medal time otherwise
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setAllWarmUpDuration($duration, $multicall = false)
	{
		if (!is_int($duration)) {
			throw new InvalidArgumentException('duration = ' . print_r($duration, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$duration], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get whether the automatic warm-up phase is enabled in all modes.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getAllWarmUpDuration($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set whether to disallow players to respawn.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $disable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setDisableRespawn($disable, $multicall = false)
	{
		if (!is_bool($disable)) {
			throw new InvalidArgumentException('disable = ' . print_r($disable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$disable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get whether players are disallowed to respawn.
	 * @param bool $multicall
	 * @return bool[] {bool CurrentValue, bool NextValue}
	 */
	public function getDisableRespawn($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set whether to override the players preferences and always display all opponents.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $opponents 0: no override, 1: show all, else: minimum number of opponents
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setForceShowAllOpponents($opponents, $multicall = false)
	{
		if (!is_int($opponents)) {
			throw new InvalidArgumentException('opponents = ' . print_r($opponents, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$opponents], $multicall);
	}

	/**
	 * Get whether players are forced to show all opponents.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	public function getForceShowAllOpponents($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Set a new mode script name for script mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param string $script
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function setScriptName($script, $multicall = false)
	{
		if (!is_string($script)) {
			throw new InvalidArgumentException('script = ' . print_r($script, true));
		}
		$script = $this->secureUtf8($script);

		return $this->execute(ucfirst(__FUNCTION__), [$script], $multicall);
	}

	/**
	 * Get the current and next mode script name for script mode.
	 * @param bool $multicall
	 * @return string[] {string CurrentValue, string NextValue}
	 */
	public function getScriptName($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], [$this, 'stripBom']);
		}
		return $this->stripBom($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new time limit for legacy time attack mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $limit In milliseconds
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setTimeAttackLimit($limit, $multicall=false)
	{
		if(!is_int($limit))
			throw new InvalidArgumentException('limit = '.print_r($limit, true));

		return $this->execute(ucfirst(__FUNCTION__), array($limit), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next time limit for legacy time attack mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getTimeAttackLimit($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new synchronized start period for legacy time attack mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $synch
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setTimeAttackSynchStartPeriod($synch, $multicall=false)
	{
		if(!is_int($synch))
			throw new InvalidArgumentException('synch = '.print_r($synch, true));

		return $this->execute(ucfirst(__FUNCTION__), array($synch), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and synchronized start period for legacy time attack mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getTimeAttackSynchStartPeriod($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new time limit for legacy laps mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $limit
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setLapsTimeLimit($limit, $multicall=false)
	{
		if(!is_int($limit))
			throw new InvalidArgumentException('limit = '.print_r($limit, true));

		return $this->execute(ucfirst(__FUNCTION__), array($limit), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next time limit for legacy laps mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getLapsTimeLimit($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new number of laps for legacy laps mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $laps
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setNbLaps($laps, $multicall=false)
	{
		if(!is_int($laps))
			throw new InvalidArgumentException('laps = '.print_r($laps, true));

		return $this->execute(ucfirst(__FUNCTION__), array($laps), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next number of laps for legacy laps mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getNbLaps($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new number of laps for legacy rounds mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $laps 0: map default
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setRoundForcedLaps($laps, $multicall=false)
	{
		if(!is_int($laps))
			throw new InvalidArgumentException('laps = '.print_r($laps, true));

		return $this->execute(ucfirst(__FUNCTION__), array($laps), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next number of laps for rounds mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getRoundForcedLaps($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new points limit for legacy rounds mode (value set depends on UseNewRulesRound).
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $limit
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setRoundPointsLimit($limit, $multicall=false)
	{
		if(!is_int($limit))
			throw new InvalidArgumentException('limit = '.print_r($limit, true));

		return $this->execute(ucfirst(__FUNCTION__), array($limit), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next points limit for rounds mode (values returned depend on UseNewRulesRound).
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getRoundPointsLimit($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set the points used for the scores in legacy rounds mode.
	 * Only available to Admin.
	 * @param int[] $points Array of decreasing integers for the players from the first to last
	 * @param bool $relax True to relax the constraint checking on the scores
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setRoundCustomPoints($points, $relax=false, $multicall=false)
	{
		if(!is_array($points))
			throw new InvalidArgumentException('points = '.print_r($points, true));
		if(!is_bool($relax))
			throw new InvalidArgumentException('relax = '.print_r($relax, true));

		return $this->execute(ucfirst(__FUNCTION__), array($points, $relax), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Gets the points used for the scores in legacy rounds mode.
	 * @param bool $multicall
	 * @return int[]
	 */
	function getRoundCustomPoints($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set if new rules are used for legacy rounds mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $newRules
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setUseNewRulesRound($newRules, $multicall=false)
	{
		if(!is_bool($newRules))
			throw new InvalidArgumentException('newRules = '.print_r($newRules, true));

		return $this->execute(ucfirst(__FUNCTION__), array($newRules), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get if the new rules are used for legacy rounds mode (Current and next values).
	 * @param bool $multicall
	 * @return bool[] {bool CurrentValue, bool NextValue}
	 */
	function getUseNewRulesRound($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new points limit for team mode (value set depends on UseNewRulesTeam).
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $limit
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setTeamPointsLimit($limit, $multicall=false)
	{
		if(!is_int($limit))
			throw new InvalidArgumentException('limit = '.print_r($limit, true));

		return $this->execute(ucfirst(__FUNCTION__), array($limit), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next points limit for team mode (values returned depend on UseNewRulesTeam).
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getTeamPointsLimit($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set a new number of maximum points per round for team mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $max
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setMaxPointsTeam($max, $multicall=false)
	{
		if(!is_int($max))
			throw new InvalidArgumentException('max = '.print_r($max, true));

		return $this->execute(ucfirst(__FUNCTION__), array($max), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the current and next number of maximum points per round for team mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getMaxPointsTeam($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set if new rules are used for team mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param bool $newRules
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setUseNewRulesTeam($newRules, $multicall=false)
	{
		if(!is_bool($newRules))
			throw new InvalidArgumentException('newRules = '.print_r($newRules, true));

		return $this->execute(ucfirst(__FUNCTION__), array($newRules), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get if the new rules are used for team mode (Current and next values).
	 * @param bool $multicall
	 * @return bool[] {bool CurrentValue, bool NextValue}
	 */
	function getUseNewRulesTeam($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set the points needed for victory in Cup mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $limit
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setCupPointsLimit($limit, $multicall=false)
	{
		if(!is_int($limit))
			throw new InvalidArgumentException('limit = '.print_r($limit, true));

		return $this->execute(ucfirst(__FUNCTION__), array($limit), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the points needed for victory in Cup mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getCupPointsLimit($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Sets the number of rounds before going to next map in Cup mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $rounds
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setCupRoundsPerMap($rounds, $multicall=false)
	{
		if(!is_int($rounds))
			throw new InvalidArgumentException('rounds = '.print_r($rounds, true));

		return $this->execute(ucfirst(__FUNCTION__), array($rounds), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the number of rounds before going to next map in Cup mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getCupRoundsPerMap($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set whether to enable the automatic warm-up phase in Cup mode.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $duration Number of rounds, 0: no warm-up
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setCupWarmUpDuration($duration, $multicall=false)
	{
		if(!is_int($duration))
			throw new InvalidArgumentException('duration = '.print_r($duration, true));

		return $this->execute(ucfirst(__FUNCTION__), array($duration), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get whether the automatic warm-up phase is enabled in Cup mode.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getCupWarmUpDuration($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Set the number of winners to determine before the match is considered over.
	 * Only available to Admin.
	 * Requires a map restart to be taken into account.
	 * @param int $winners
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	function setCupNbWinners($winners, $multicall=false)
	{
		if(!is_int($winners))
			throw new InvalidArgumentException('winners = '.print_r($winners, true));

		return $this->execute(ucfirst(__FUNCTION__), array($winners), $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Get the number of winners to determine before the match is considered over.
	 * @param bool $multicall
	 * @return int[] {int CurrentValue, int NextValue}
	 */
	function getCupNbWinners($multicall=false)
	{
		return $this->execute(ucfirst(__FUNCTION__), array(), $multicall);
	}

	/**
	 * Returns the current map index in the selection, or -1 if the map is no longer in the selection.
	 * @param bool $multicall
	 * @return int
	 */
	public function getCurrentMapIndex($multicall = false): int
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns the map index in the selection that will be played next (unless the current one is restarted...)
	 * @param bool $multicall
	 * @return int
	 */
	public function getNextMapIndex($multicall = false): int
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Sets the map index in the selection that will be played next (unless the current one is restarted...)
	 * @param int $index
	 * @param bool $multicall
	 * @return bool
	 */
	public function setNextMapIndex(int $index, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$index], $multicall);
	}

	/**
	 * Sets the map in the selection that will be played next (unless the current one is restarted...)
	 * @param string $ident
	 * @param bool $multicall
	 * @return bool
	 */
	public function setNextMapIdent(string $ident, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$ident], $multicall);
	}

	/**
	 * Immediately jumps to the map designated by the index in the selection.
	 * @param int $index
	 * @param bool $multicall
	 * @return bool
	 */
	public function jumpToMapIndex(int $index, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$index], $multicall);
	}

	/**
	 * Immediately jumps to the map designated by its identifier (it must be in the selection).
	 * @param string $ident
	 * @param bool $multicall
	 * @return bool
	 */
	public function jumpToMapIdent(string $ident, $multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [$ident], $multicall);
	}

	/**
	 * Returns a struct containing the infos for the current map.
	 * @param bool $multicall
	 * @return Structures\Map
	 */
	public function getCurrentMapInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Map'));
		}
		return Structures\Map::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns a struct containing the infos for the next map.
	 * @param bool $multicall
	 * @return Structures\Map
	 */
	public function getNextMapInfo($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('Map'));
		}
		return Structures\Map::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Returns a struct containing the infos for the map with the specified filename.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return Structures\Map
	 * @throws InvalidArgumentException
	 */
	public function getMapInfo(string $filename, $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$filename], $this->structHandler('Map'));
		}
		return Structures\Map::fromArray($this->execute(ucfirst(__FUNCTION__), [$filename]));
	}

	/**
	 * Returns a boolean if the map with the specified filename matches the current server settings.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function checkMapForCurrentServerParams(string $filename, $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Returns a list of maps among the current selection of the server.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\Map[]
	 */
	public function getMapList(int $length = -1, int $offset = 0, $multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('Map', true));
		}
		return Structures\Map::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Add the map with the specified filename at the end of the current selection.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return bool
	 */
	public function addMap(string $filename, $multicall = false)
	{
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Add the list of maps with the specified filenames at the end of the current selection.
	 * Only available to Admin.
	 * @param string[] $filenames Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually added
	 * @throws InvalidArgumentException
	 */
	public function addMapList($filenames, $multicall = false)
	{
		if (!is_array($filenames)) {
			throw new InvalidArgumentException('filenames = ' . print_r($filenames, true));
		}
		$filenames = $this->secureUtf8($filenames);

		return $this->execute(ucfirst(__FUNCTION__), [$filenames], $multicall);
	}

	/**
	 * Remove the map with the specified filename from the current selection.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function removeMap($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Remove the list of maps with the specified filenames from the current selection.
	 * Only available to Admin.
	 * @param string[] $filenames Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually removed
	 * @throws InvalidArgumentException
	 */
	public function removeMapList($filenames, $multicall = false)
	{
		if (!is_array($filenames)) {
			throw new InvalidArgumentException('filenames = ' . print_r($filenames, true));
		}
		$filenames = $this->secureUtf8($filenames);

		return $this->execute(ucfirst(__FUNCTION__), [$filenames], $multicall);
	}

	/**
	 * Insert the map with the specified filename after the current map.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function insertMap($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Insert the list of maps with the specified filenames after the current map.
	 * Only available to Admin.
	 * @param string[] $filenames Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually inserted
	 * @throws InvalidArgumentException
	 */
	public function insertMapList($filenames, $multicall = false)
	{
		if (!is_array($filenames)) {
			throw new InvalidArgumentException('filenames = ' . print_r($filenames, true));
		}
		$filenames = $this->secureUtf8($filenames);

		return $this->execute(ucfirst(__FUNCTION__), [$filenames], $multicall);
	}

	/**
	 * Set as next map the one with the specified filename, if it is present in the selection.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function chooseNextMap($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Set as next maps the list of maps with the specified filenames, if they are present in the selection.
	 * Only available to Admin.
	 * @param string[] $filenames Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually chosen
	 * @throws InvalidArgumentException
	 */
	public function chooseNextMapList($filenames, $multicall = false)
	{
		if (!is_array($filenames)) {
			throw new InvalidArgumentException('filenames = ' . print_r($filenames, true));
		}
		$filenames = $this->secureUtf8($filenames);

		return $this->execute(ucfirst(__FUNCTION__), [$filenames], $multicall);
	}

	/**
	 * Set a list of maps defined in the playlist with the specified filename as the current selection of the server, and load the gameinfos from the same file.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps in the new list
	 * @throws InvalidArgumentException
	 */
	public function loadMatchSettings($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Add a list of maps defined in the playlist with the specified filename at the end of the current selection.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually added
	 * @throws InvalidArgumentException
	 */
	public function appendPlaylistFromMatchSettings($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Save the current selection of map in the playlist with the specified filename, as well as the current gameinfos.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps in the saved playlist
	 * @throws InvalidArgumentException
	 */
	public function saveMatchSettings($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Insert a list of maps defined in the playlist with the specified filename after the current map.
	 * Only available to Admin.
	 * @param string $filename Relative to the Maps path
	 * @param bool $multicall
	 * @return int Number of maps actually inserted
	 * @throws InvalidArgumentException
	 */
	public function insertPlaylistFromMatchSettings($filename, $multicall = false)
	{
		if (!is_string($filename) || !strlen($filename)) {
			throw new InvalidArgumentException('filename = ' . print_r($filename, true));
		}
		$filename = $this->secureUtf8($filename);

		return $this->execute(ucfirst(__FUNCTION__), [$filename], $multicall);
	}

	/**
	 * Returns the list of players on the server.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param int $compatibility 0: united, 1: forever, 2: forever including servers
	 * @param bool $multicall
	 * @return Structures\PlayerInfo[]
	 * @throws InvalidArgumentException
	 */
	public function getPlayerList($length = -1, $offset = 0, $compatibility = 1, $multicall = false)
	{
		if (!is_int($length)) {
			throw new InvalidArgumentException('length = ' . print_r($length, true));
		}
		if (!is_int($offset)) {
			throw new InvalidArgumentException('offset = ' . print_r($offset, true));
		}
		if (!is_int($compatibility) || $compatibility < 0 || $compatibility > 2) {
			throw new InvalidArgumentException('compatibility = ' . print_r($compatibility, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset, $compatibility], $this->structHandler('PlayerInfo', true));
		}
		return Structures\PlayerInfo::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset, $compatibility]));
	}

	/**
	 * Returns a struct containing the infos on the player with the specified login.
	 * @param mixed $player Login or player object
	 * @param int $compatibility 0: united, 1: forever
	 * @param bool $multicall
	 * @return Structures\PlayerInfo
	 * @throws InvalidArgumentException
	 */
	public function getPlayerInfo($player, $compatibility = 1, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		if ($compatibility !== 0 && $compatibility !== 1) {
			throw new InvalidArgumentException('compatibility = ' . print_r($compatibility, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$login, $compatibility], $this->structHandler('PlayerInfo'));
		}
		return Structures\PlayerInfo::fromArray($this->execute(ucfirst(__FUNCTION__), [$login, $compatibility]));
	}

	/**
	 * Returns a struct containing the infos on the player with the specified login.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return Structures\PlayerDetailedInfo
	 * @throws InvalidArgumentException
	 */
	public function getDetailedPlayerInfo($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$login], $this->structHandler('PlayerDetailedInfo'));
		}
		return Structures\PlayerDetailedInfo::fromArray($this->execute(ucfirst(__FUNCTION__), [$login]));
	}

	/**
	 * Returns a struct containing the player infos of the game server
	 * (ie: in case of a basic server, itself; in case of a relay server, the main server)
	 * @param int $compatibility 0: united, 1: forever
	 * @param bool $multicall
	 * @return Structures\PlayerInfo
	 * @throws InvalidArgumentException
	 */
	public function getMainServerPlayerInfo($compatibility = 1, $multicall = false)
	{
		if (!is_int($compatibility)) {
			throw new InvalidArgumentException('compatibility = ' . print_r($compatibility, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$compatibility], $this->structHandler('PlayerInfo'));
		}
		return Structures\PlayerInfo::fromArray($this->execute(ucfirst(__FUNCTION__), [$compatibility]));
	}

	/**
	 * Returns the current rankings for the match in progress.
	 * In script modes, scores aren't returned.
	 * In team modes, the scores for the two teams are returned.
	 * In other modes, it's the individual players' scores.
	 * @param int $length Maximum number of infos to be returned
	 * @param int $offset Starting index in the list
	 * @param bool $multicall
	 * @return Structures\PlayerRanking[]
	 * @throws InvalidArgumentException
	 */
	public function getCurrentRanking($length = -1, $offset = 0, $multicall = false)
	{
		if (!is_int($length)) {
			throw new InvalidArgumentException('length = ' . print_r($length, true));
		}
		if (!is_int($offset)) {
			throw new InvalidArgumentException('offset = ' . print_r($offset, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$length, $offset], $this->structHandler('PlayerRanking', true));
		}
		return Structures\PlayerRanking::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$length, $offset]));
	}

	/**
	 * Returns the current ranking of the player with the specified login (or list of comma-separated logins) for the match in progress.
	 * In script modes, scores aren't returned.
	 * In other modes, it's the individual players' scores.
	 * @param mixed $players Login, player object or array
	 * @param bool $multicall
	 * @return Structures\PlayerRanking[]
	 * @throws InvalidArgumentException
	 */
	public function getCurrentRankingForLogin($players, $multicall = false)
	{
		$logins = $this->getLogins($players);
		if ($logins === false) {
			throw new InvalidArgumentException('players = ' . print_r($players, true));
		}

		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [$logins], $this->structHandler('PlayerRanking', true));
		}
		return Structures\PlayerRanking::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__), [$logins]));
	}

	/**
	 * Returns the current winning team for the race in progress.
	 * @param bool $multicall
	 * @return int -1: if not in team mode or draw match, 0 or 1 otherwise
	 */
	public function getCurrentWinnerTeam($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Force the scores of the current game.
	 * Only available in rounds and team mode.
	 * Only available to Admin/SuperAdmin.
	 * @param int[][] $scores Array of structs {int PlayerId, int Score}
	 * @param bool $silent True to update silently (only available for SuperAdmin)
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function forceScores($scores, $silent, $multicall = false)
	{
		if (!is_array($scores)) {
			throw new InvalidArgumentException('scores = ' . print_r($scores, true));
		}
		foreach ($scores as $i => $score) {
			if (!is_array($score)) {
				throw new InvalidArgumentException('score[' . $i . '] = ' . print_r($score, true));
			}
			if (!isset($score['PlayerId']) || !is_int($score['PlayerId'])) {
				throw new InvalidArgumentException('score[' . $i . ']["PlayerId"] = ' . print_r($score, true));
			}
			if (!isset($score['Score']) || !is_int($score['Score'])) {
				throw new InvalidArgumentException('score[' . $i . ']["Score"] = ' . print_r($score, true));
			}
		}
		if (!is_bool($silent)) {
			throw new InvalidArgumentException('silent = ' . print_r($silent, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$scores, $silent], $multicall);
	}

	/**
	 * Force the team of the player.
	 * Only available in team mode.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param int $team 0 or 1
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function forcePlayerTeam($player, $team, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		if ($team !== 0 && $team !== 1) {
			throw new InvalidArgumentException('team = ' . print_r($team, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $team], $multicall);
	}

	/**
	 * Force the spectating status of the player.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param int $mode 0: user selectable, 1: spectator, 2: player, 3: spectator but keep selectable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function forceSpectator($player, $mode, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}
		if (!is_int($mode) || $mode < 0 || $mode > 3) {
			throw new InvalidArgumentException('mode = ' . print_r($mode, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login, $mode], $multicall);
	}

	/**
	 * Force spectators to look at a specific player.
	 * Only available to Admin.
	 * @param mixed $spectator Login or player object; empty for all
	 * @param mixed $target Login or player object; empty for automatic
	 * @param int $camera -1: leave unchanged, 0: replay, 1: follow, 2: free
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function forceSpectatorTarget($spectator, $target, $camera, $multicall = false)
	{
		$spectatorLogin = $this->getLogin($spectator, true);
		if ($spectatorLogin === false) {
			throw new InvalidArgumentException('player = ' . print_r($spectator, true));
		}
		$targetLogin = $this->getLogin($target, true);
		if ($targetLogin === false) {
			throw new InvalidArgumentException('target = ' . print_r($target, true));
		}
		if (!is_int($camera) || $camera < -1 || $camera > 2) {
			throw new InvalidArgumentException('camera = ' . print_r($camera, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$spectatorLogin, $targetLogin, $camera], $multicall);
	}

	/**
	 * Pass the login of the spectator.
	 * A spectator that once was a player keeps his player slot, so that he can go back to player mode.
	 * Calling this function frees this slot for another player to connect.
	 * Only available to Admin.
	 * @param mixed $player Login or player object
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function spectatorReleasePlayerSlot($player, $multicall = false)
	{
		$login = $this->getLogin($player);
		if ($login === false) {
			throw new InvalidArgumentException('player = ' . print_r($player, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$login], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Enable control of the game flow: the game will wait for the caller to validate state transitions.
	 * Only available to Admin.
	 * @param bool $enable
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function manualFlowControlEnable($enable = true, $multicall = false)
	{
		if (!is_bool($enable)) {
			throw new InvalidArgumentException('enable = ' . print_r($enable, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [$enable], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Allows the game to proceed.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function manualFlowControlProceed($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns whether the manual control of the game flow is enabled.
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return int 0: no, 1: yes by the xml-rpc client making the call, 2: yes by some other xml-rpc client
	 */
	public function manualFlowControlIsEnabled($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns the transition that is currently blocked, or '' if none.
	 * (That's exactly the value last received by the callback.)
	 * Only available to Admin.
	 * @param bool $multicall
	 * @return string
	 */
	public function manualFlowControlGetCurTransition($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Returns the current match ending condition.
	 * @param bool $multicall
	 * @return string 'Playing', 'ChangeMap' or 'Finished'
	 */
	public function checkEndMatchCondition($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Returns a struct containing the networks stats of the server.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return Structures\NetworkStats
	 */
	public function getNetworkStats($multicall = false)
	{
		if ($multicall) {
			return $this->execute(ucfirst(__FUNCTION__), [], $this->structHandler('NetworkStats'));
		}
		return Structures\NetworkStats::fromArray($this->execute(ucfirst(__FUNCTION__)));
	}

	/**
	 * Start a server on lan, using the current configuration.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function startServerLan($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * Start a server on internet, using the current configuration.
	 * Only available to SuperAdmin.
	 * @param bool $multicall
	 * @return bool
	 */
	public function startServerInternet($multicall = false)
	{
		return $this->execute(ucfirst(__FUNCTION__), [], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Join the server on lan.
	 * Only available on client.
	 * Only available to Admin.
	 * @param string $host IPv4 with optionally a port (eg. '192.168.1.42:2350')
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function joinServerLan($host, $password = '', $multicall = false)
	{
		if (!is_string($host)) {
			throw new InvalidArgumentException('host = ' . print_r($host, true));
		}
		if (!is_string($password)) {
			throw new InvalidArgumentException('password = ' . print_r($password, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [['Server' => $host, 'ServerPassword' => $password]], $multicall);
	}

	/**
	 * @deprecated since version 2022-03-21
	 * Join the server on internet.
	 * Only available on client.
	 * Only available to Admin.
	 * @param string $host Server login or IPv4 with optionally a port (eg. '192.168.1.42:2350')
	 * @param string $password
	 * @param bool $multicall
	 * @return bool
	 * @throws InvalidArgumentException
	 */
	public function joinServerInternet($host, $password = '', $multicall = false)
	{
		if (!is_string($host)) {
			throw new InvalidArgumentException('host = ' . print_r($host, true));
		}
		if (!is_string($password)) {
			throw new InvalidArgumentException('password = ' . print_r($password, true));
		}

		return $this->execute(ucfirst(__FUNCTION__), [['Server' => $host, 'ServerPassword' => $password]], $multicall);
	}
}

/**
 * Exception Dedicated to Invalid Argument Error on Request Call
 */
class InvalidArgumentException extends \Exception
{
}