use NotCloneable;

use NotSerializable;

public const BROADCAST_CHANNEL_ADMINISTRATIVE = "pocketmine.broadcast.admin";

public const BROADCAST_CHANNEL_USERS = "pocketmine.broadcast.user";

public const DEFAULT_SERVER_NAME = VersionInfo::NAME . " Server";

public const DEFAULT_MAX_PLAYERS = 20;

public const DEFAULT_PORT_IPV4 = 19132;

public const DEFAULT_PORT_IPV6 = 19133;

public const DEFAULT_MAX_VIEW_DISTANCE = 16;

/**

public const TARGET_TICKS_PER_SECOND = 20;

/**

public const TARGET_SECONDS_PER_TICK = 1 / self::TARGET_TICKS_PER_SECOND;

public const TARGET_NANOSECONDS_PER_TICK = 1_000_000_000 / self::TARGET_TICKS_PER_SECOND;

/**

private const TPS_OVERLOAD_WARNING_THRESHOLD = self::TARGET_TICKS_PER_SECOND * 0.6;

private const TICKS_PER_WORLD_CACHE_CLEAR = 5 * self::TARGET_TICKS_PER_SECOND;

private const TICKS_PER_TPS_OVERLOAD_WARNING = 5 * self::TARGET_TICKS_PER_SECOND;

private const TICKS_PER_STATS_REPORT = 300 * self::TARGET_TICKS_PER_SECOND;

private const DEFAULT_ASYNC_COMPRESSION_THRESHOLD = 10_000;

private static ?Server $instance = null;

private TimeTrackingSleeperHandler $tickSleeper;

private BanList $banByName;

private BanList $banByIP;

private Config $operators;

private Config $whitelist;

private bool $isRunning = true;

private bool $hasStopped = false;

private PluginManager $pluginManager;

private float $profilingTickRate = self::TARGET_TICKS_PER_SECOND;

private UpdateChecker $updater;

private AsyncPool $asyncPool;

/** Counts the ticks since the server start */

private int $tickCounter = 0;

private float $nextTick = 0;

/** @var float[] */

private array $tickAverage;

/** @var float[] */

private array $useAverage;

private float $currentTPS = self::TARGET_TICKS_PER_SECOND;

private float $currentUse = 0;

private float $startTime;

private bool $doTitleTick = true;

private int $sendUsageTicker = 0;

private MemoryManager $memoryManager;

private ?ConsoleReaderChildProcessDaemon $console = null;

private ?ConsoleCommandSender $consoleSender = null;

private SimpleCommandMap $commandMap;

private CraftingManager $craftingManager;

private ResourcePackManager $resourceManager;

private WorldManager $worldManager;

private int $maxPlayers;

private bool $onlineMode = true;

private Network $network;

private bool $networkCompressionAsync = true;

private int $networkCompressionAsyncThreshold = self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD;

private Language $language;

private bool $forceLanguage = false;

private UuidInterface $serverID;

private string $dataPath;

private string $pluginPath;

private PlayerDataProvider $playerDataProvider;

/**

private array $uniquePlayers = [];

private QueryInfo $queryInfo;

private ServerConfigGroup $configGroup;

/** @var Player[] */

private array $playerList = [];

private SignalHandler $signalHandler;

/**

private array $broadcastSubscribers = [];

public function getName() : string{

return VersionInfo::NAME;

}

public function isRunning() : bool{

return $this->isRunning;

}

public function getPocketMineVersion() : string{

return VersionInfo::VERSION()->getFullVersion(true);

}

public function getVersion() : string{

return ProtocolInfo::MINECRAFT_VERSION;

}

public function getApiVersion() : string{

return VersionInfo::BASE_VERSION;

}

public function getFilePath() : string{

return \pocketmine\PATH;

}

public function getResourcePath() : string{

return \pocketmine\RESOURCE_PATH;

}

public function getDataPath() : string{

return $this->dataPath;

}

public function getPluginPath() : string{

return $this->pluginPath;

}

public function getMaxPlayers() : int{

return $this->maxPlayers;

}

/**

public function getOnlineMode() : bool{

return $this->onlineMode;

}

/**

public function requiresAuthentication() : bool{

return $this->getOnlineMode();

}

public function getPort() : int{

return $this->configGroup->getConfigInt(ServerProperties::SERVER_PORT_IPV4, self::DEFAULT_PORT_IPV4);

}

public function getPortV6() : int{

return $this->configGroup->getConfigInt(ServerProperties::SERVER_PORT_IPV6, self::DEFAULT_PORT_IPV6);

}

public function getViewDistance() : int{

return max(2, $this->configGroup->getConfigInt(ServerProperties::VIEW_DISTANCE, self::DEFAULT_MAX_VIEW_DISTANCE));

}

/**

public function getAllowedViewDistance(int $distance) : int{

return max(2, min($distance, $this->memoryManager->getViewDistance($this->getViewDistance())));

}

public function getIp() : string{

$str = $this->configGroup->getConfigString(ServerProperties::SERVER_IPV4);

return $str !== "" ? $str : "0.0.0.0";

}

public function getIpV6() : string{

$str = $this->configGroup->getConfigString(ServerProperties::SERVER_IPV6);

return $str !== "" ? $str : "::";

}

public function getServerUniqueId() : UuidInterface{

return $this->serverID;

}

public function getGamemode() : GameMode{

return GameMode::fromString($this->configGroup->getConfigString(ServerProperties::GAME_MODE)) ?? GameMode::SURVIVAL;

}

public function getForceGamemode() : bool{

return $this->configGroup->getConfigBool(ServerProperties::FORCE_GAME_MODE, false);

}

/**

public function getDifficulty() : int{

return $this->configGroup->getConfigInt(ServerProperties::DIFFICULTY, World::DIFFICULTY_NORMAL);

}

public function hasWhitelist() : bool{

return $this->configGroup->getConfigBool(ServerProperties::WHITELIST, false);

}

public function isHardcore() : bool{

return $this->configGroup->getConfigBool(ServerProperties::HARDCORE, false);

}

public function getMotd() : string{

return $this->configGroup->getConfigString(ServerProperties::MOTD, self::DEFAULT_SERVER_NAME);

}

public function getLoader() : ThreadSafeClassLoader{

return $this->autoloader;

}

public function getLogger() : AttachableThreadSafeLogger{

return $this->logger;

}

public function getUpdater() : UpdateChecker{

return $this->updater;

}

public function getPluginManager() : PluginManager{

return $this->pluginManager;

}

public function getCraftingManager() : CraftingManager{

return $this->craftingManager;

}

public function getResourcePackManager() : ResourcePackManager{

return $this->resourceManager;

}

public function getWorldManager() : WorldManager{

return $this->worldManager;

}

public function getAsyncPool() : AsyncPool{

return $this->asyncPool;

}

public function getTick() : int{

return $this->tickCounter;

}

/**

public function getTicksPerSecond() : float{

return round($this->currentTPS, 2);

}

/**

public function getTicksPerSecondAverage() : float{

return round(array_sum($this->tickAverage) / count($this->tickAverage), 2);

}

/**

public function getTickUsage() : float{

return round($this->currentUse * 100, 2);

}

/**

public function getTickUsageAverage() : float{

return round((array_sum($this->useAverage) / count($this->useAverage)) * 100, 2);

}

public function getStartTime() : float{

return $this->startTime;

}

public function getCommandMap() : SimpleCommandMap{

return $this->commandMap;

}

/**

public function getOnlinePlayers() : array{

return $this->playerList;

}

public function shouldSavePlayerData() : bool{

return $this->configGroup->getPropertyBool(Yml::PLAYER_SAVE_PLAYER_DATA, true);

}

public function getOfflinePlayer(string $name) : Player|OfflinePlayer|null{

$name = strtolower($name);

$result = $this->getPlayerExact($name);

if($result === null){

$result = new OfflinePlayer($name, $this->getOfflinePlayerData($name));

}

return $result;

}

/**

public function hasOfflinePlayerData(string $name) : bool{

return $this->playerDataProvider->hasData($name);

}

public function getOfflinePlayerData(string $name) : ?CompoundTag{

return Timings::$syncPlayerDataLoad->time(function() use ($name) : ?CompoundTag{

try{

return $this->playerDataProvider->loadData($name);

}catch(PlayerDataLoadException $e){

$this->logger->debug("Failed to load player data for $name: " . $e->getMessage());

$this->logger->error($this->language->translate(KnownTranslationFactory::pocketmine_data_playerCorrupted($name)));

return null;

}

});

}

public function saveOfflinePlayerData(string $name, CompoundTag $nbtTag) : void{

$ev = new PlayerDataSaveEvent($nbtTag, $name, $this->getPlayerExact($name));

if(!$this->shouldSavePlayerData()){

$ev->cancel();

}

$ev->call();

if(!$ev->isCancelled()){

Timings::$syncPlayerDataSave->time(function() use ($name, $ev) : void{

try{

$this->playerDataProvider->saveData($name, $ev->getSaveData());

}catch(PlayerDataSaveException $e){

$this->logger->critical($this->language->translate(KnownTranslationFactory::pocketmine_data_saveError($name, $e->getMessage())));

$this->logger->logException($e);

}

});

}

}

/**

public function createPlayer(NetworkSession $session, PlayerInfo $playerInfo, bool $authenticated, ?CompoundTag $offlinePlayerData) : Promise{

$ev = new PlayerCreationEvent($session);

$ev->call();

$class = $ev->getPlayerClass();

if($offlinePlayerData !== null && ($world = $this->worldManager->getWorldByName($offlinePlayerData->getString(Player::TAG_LEVEL, ""))) !== null){

$playerPos = EntityDataHelper::parseLocation($offlinePlayerData, $world);

}else{

$world = $this->worldManager->getDefaultWorld();

if($world === null){

throw new AssumptionFailedError("Default world should always be loaded");

}

$playerPos = null;

}

/** @phpstan-var PromiseResolver<Player> $playerPromiseResolver */

$playerPromiseResolver = new PromiseResolver();

$createPlayer = function(Location $location) use ($playerPromiseResolver, $class, $session, $playerInfo, $authenticated, $offlinePlayerData) : void{

/** @see Player::__construct() */

$player = new $class($this, $session, $playerInfo, $authenticated, $location, $offlinePlayerData);

if(!$player->hasPlayedBefore()){

$player->onGround = true; //TODO: this hack is needed for new players in-air ticks - they don't get detected as on-ground until they move

}

$playerPromiseResolver->resolve($player);

};

if($playerPos === null){ //new player or no valid position due to world not being loaded

$world->requestSafeSpawn()->onCompletion(

function(Position $spawn) use ($createPlayer, $playerPromiseResolver, $session, $world) : void{

if(!$session->isConnected()){

$playerPromiseResolver->reject();

return;

}

$createPlayer(Location::fromObject($spawn, $world));

},

function() use ($playerPromiseResolver, $session) : void{

if($session->isConnected()){

$session->disconnectWithError(KnownTranslationFactory::pocketmine_disconnect_error_respawn());

}

$playerPromiseResolver->reject();

}

);

}else{ //returning player with a valid position - safe spawn not required

$createPlayer($playerPos);

}

return $playerPromiseResolver->getPromise();

}

/**

public function getPlayerByPrefix(string $name) : ?Player{

$found = null;

$name = strtolower($name);

$delta = PHP_INT_MAX;

foreach($this->getOnlinePlayers() as $player){

if(stripos($player->getName(), $name) === 0){

$curDelta = strlen($player->getName()) - strlen($name);

if($curDelta < $delta){

$found = $player;

$delta = $curDelta;

}

if($curDelta === 0){

break;

}

}

}

return $found;

}

/**

public function getPlayerExact(string $name) : ?Player{

$name = strtolower($name);

foreach($this->getOnlinePlayers() as $player){

if(strtolower($player->getName()) === $name){

return $player;

}

}

return null;

}

/**

public function getPlayerByRawUUID(string $rawUUID) : ?Player{

return $this->playerList[$rawUUID] ?? null;

}

/**

public function getPlayerByUUID(UuidInterface $uuid) : ?Player{

return $this->getPlayerByRawUUID($uuid->getBytes());

}

public function getConfigGroup() : ServerConfigGroup{

return $this->configGroup;

}

/**

public function getPluginCommand(string $name){

if(($command = $this->commandMap->getCommand($name)) instanceof PluginOwned){

return $command;

}else{

return null;

}

}

public function getNameBans() : BanList{

return $this->banByName;

}

public function getIPBans() : BanList{

return $this->banByIP;

}

public function addOp(string $name) : void{

$this->operators->set(strtolower($name), true);

if(($player = $this->getPlayerExact($name)) !== null){

$player->setBasePermission(DefaultPermissions::ROOT_OPERATOR, true);

}

$this->operators->save();

}

public function removeOp(string $name) : void{

$lowercaseName = strtolower($name);

foreach(Utils::promoteKeys($this->operators->getAll()) as $operatorName => $_){

$operatorName = (string) $operatorName;

if($lowercaseName === strtolower($operatorName)){

$this->operators->remove($operatorName);

}

}

if(($player = $this->getPlayerExact($name)) !== null){

$player->unsetBasePermission(DefaultPermissions::ROOT_OPERATOR);

}

$this->operators->save();

}

public function addWhitelist(string $name) : void{

$this->whitelist->set(strtolower($name), true);

$this->whitelist->save();

}

public function removeWhitelist(string $name) : void{

$this->whitelist->remove(strtolower($name));

$this->whitelist->save();

}

public function isWhitelisted(string $name) : bool{

return !$this->hasWhitelist() || $this->operators->exists($name, true) || $this->whitelist->exists($name, true);

}

public function isOp(string $name) : bool{

return $this->operators->exists($name, true);

}

public function getWhitelisted() : Config{

return $this->whitelist;

}

public function getOps() : Config{

return $this->operators;

}

/**

public function getCommandAliases() : array{

$section = $this->configGroup->getProperty(Yml::ALIASES);

$result = [];

if(is_array($section)){

foreach(Utils::promoteKeys($section) as $key => $value){

//TODO: more validation needed here

//key might not be a string, value might not be list<string>

$commands = [];

if(is_array($value)){

$commands = $value;

}else{

$commands[] = (string) $value;

}

$result[(string) $key] = $commands;

}

}

return $result;

}

public static function getInstance() : Server{

if(self::$instance === null){

throw new \RuntimeException("Attempt to retrieve Server instance outside server thread");

}

return self::$instance;

}

public function __construct(

private ThreadSafeClassLoader $autoloader,

private AttachableThreadSafeLogger $logger,

string $dataPath,

string $pluginPath

){

if(self::$instance !== null){

throw new \LogicException("Only one server instance can exist at once");

}

self::$instance = $this;

$this->startTime = microtime(true);

$this->tickAverage = array_fill(0, self::TARGET_TICKS_PER_SECOND, self::TARGET_TICKS_PER_SECOND);

$this->useAverage = array_fill(0, self::TARGET_TICKS_PER_SECOND, 0);

Timings::init();

$this->tickSleeper = new TimeTrackingSleeperHandler(Timings::$serverInterrupts);

$this->signalHandler = new SignalHandler(function() : void{

$this->logger->info("Received signal interrupt, stopping the server");

$this->shutdown();

});

try{

foreach([

$dataPath,

$pluginPath,

Path::join($dataPath, "worlds"),

Path::join($dataPath, "players")

] as $neededPath){

if(!file_exists($neededPath)){

mkdir($neededPath, 0777);

}

}

$this->dataPath = realpath($dataPath) . DIRECTORY_SEPARATOR;

$this->pluginPath = realpath($pluginPath) . DIRECTORY_SEPARATOR;

$this->logger->info("Loading server configuration");

$pocketmineYmlPath = Path::join($this->dataPath, "pocketmine.yml");

if(!file_exists($pocketmineYmlPath)){

$content = Filesystem::fileGetContents(Path::join(\pocketmine\RESOURCE_PATH, "pocketmine.yml"));

if(VersionInfo::IS_DEVELOPMENT_BUILD){

$content = str_replace("preferred-channel: stable", "preferred-channel: beta", $content);

}

@file_put_contents($pocketmineYmlPath, $content);

}

$this->configGroup = new ServerConfigGroup(

new Config($pocketmineYmlPath, Config::YAML, []),

new Config(Path::join($this->dataPath, "server.properties"), Config::PROPERTIES, [

ServerProperties::MOTD => self::DEFAULT_SERVER_NAME,

ServerProperties::SERVER_PORT_IPV4 => self::DEFAULT_PORT_IPV4,

ServerProperties::SERVER_PORT_IPV6 => self::DEFAULT_PORT_IPV6,

ServerProperties::ENABLE_IPV6 => true,

ServerProperties::WHITELIST => false,

ServerProperties::MAX_PLAYERS => self::DEFAULT_MAX_PLAYERS,

ServerProperties::GAME_MODE => GameMode::SURVIVAL->name, //TODO: this probably shouldn't use the enum name directly

ServerProperties::FORCE_GAME_MODE => false,

ServerProperties::HARDCORE => false,

ServerProperties::PVP => true,

ServerProperties::DIFFICULTY => World::DIFFICULTY_NORMAL,

ServerProperties::DEFAULT_WORLD_GENERATOR_SETTINGS => "",

ServerProperties::DEFAULT_WORLD_NAME => "world",

ServerProperties::DEFAULT_WORLD_SEED => "",

ServerProperties::DEFAULT_WORLD_GENERATOR => "DEFAULT",

ServerProperties::ENABLE_QUERY => true,

ServerProperties::AUTO_SAVE => true,

ServerProperties::VIEW_DISTANCE => self::DEFAULT_MAX_VIEW_DISTANCE,

ServerProperties::XBOX_AUTH => true,

ServerProperties::LANGUAGE => "eng"

])

);

$debugLogLevel = $this->configGroup->getPropertyInt(Yml::DEBUG_LEVEL, 1);

if($this->logger instanceof MainLogger){

$this->logger->setLogDebug($debugLogLevel > 1);

}

$this->forceLanguage = $this->configGroup->getPropertyBool(Yml::SETTINGS_FORCE_LANGUAGE, false);

$selectedLang = $this->configGroup->getConfigString(ServerProperties::LANGUAGE, $this->configGroup->getPropertyString("settings.language", Language::FALLBACK_LANGUAGE));

try{

$this->language = new Language($selectedLang);

}catch(LanguageNotFoundException $e){

$this->logger->error($e->getMessage());

try{

$this->language = new Language(Language::FALLBACK_LANGUAGE);

}catch(LanguageNotFoundException $e){

$this->logger->emergency("Fallback language \"" . Language::FALLBACK_LANGUAGE . "\" not found");

return;

}

}

$this->logger->info($this->language->translate(KnownTranslationFactory::language_selected($this->language->getName(), $this->language->getLang())));

if(VersionInfo::IS_DEVELOPMENT_BUILD){

if(!$this->configGroup->getPropertyBool(Yml::SETTINGS_ENABLE_DEV_BUILDS, false)){

$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error1(VersionInfo::NAME)));

$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error2()));

$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error3()));

$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error4(Yml::SETTINGS_ENABLE_DEV_BUILDS)));

$this->logger->emergency($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_error5("https://github.com/pmmp/PocketMine-MP/releases")));

$this->forceShutdownExit();

return;

}

$this->logger->warning(str_repeat("-", 40));

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_warning1(VersionInfo::NAME)));

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_warning2()));

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_devBuild_warning3()));

$this->logger->warning(str_repeat("-", 40));

}

$this->memoryManager = new MemoryManager($this);

$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_start(TextFormat::AQUA . $this->getVersion() . TextFormat::RESET)));

if(($poolSize = $this->configGroup->getPropertyString(Yml::SETTINGS_ASYNC_WORKERS, "auto")) === "auto"){

$poolSize = 2;

$processors = Utils::getCoreCount() - 2;

if($processors > 0){

$poolSize = max(1, $processors);

}

}else{

$poolSize = max(1, (int) $poolSize);

}

TimingsHandler::setEnabled($this->configGroup->getPropertyBool(Yml::SETTINGS_ENABLE_PROFILING, false));

$this->profilingTickRate = $this->configGroup->getPropertyInt(Yml::SETTINGS_PROFILE_REPORT_TRIGGER, self::TARGET_TICKS_PER_SECOND);

$this->asyncPool = new AsyncPool($poolSize, max(-1, $this->configGroup->getPropertyInt(Yml::MEMORY_ASYNC_WORKER_HARD_LIMIT, 256)), $this->autoloader, $this->logger, $this->tickSleeper);

$this->asyncPool->addWorkerStartHook(function(int $i) : void{

if(TimingsHandler::isEnabled()){

$this->asyncPool->submitTaskToWorker(TimingsControlTask::setEnabled(true), $i);

}

});

TimingsHandler::getToggleCallbacks()->add(function(bool $enable) : void{

foreach($this->asyncPool->getRunningWorkers() as $workerId){

$this->asyncPool->submitTaskToWorker(TimingsControlTask::setEnabled($enable), $workerId);

}

});

TimingsHandler::getReloadCallbacks()->add(function() : void{

foreach($this->asyncPool->getRunningWorkers() as $workerId){

$this->asyncPool->submitTaskToWorker(TimingsControlTask::reload(), $workerId);

}

});

TimingsHandler::getCollectCallbacks()->add(function() : array{

$promises = [];

foreach($this->asyncPool->getRunningWorkers() as $workerId){

/** @phpstan-var PromiseResolver<list<string>> $resolver */

$resolver = new PromiseResolver();

$this->asyncPool->submitTaskToWorker(new TimingsCollectionTask($resolver), $workerId);

$promises[] = $resolver->getPromise();

}

return $promises;

});

$netCompressionThreshold = -1;

if($this->configGroup->getPropertyInt(Yml::NETWORK_BATCH_THRESHOLD, 256) >= 0){

$netCompressionThreshold = $this->configGroup->getPropertyInt(Yml::NETWORK_BATCH_THRESHOLD, 256);

}

if($netCompressionThreshold < 0){

$netCompressionThreshold = null;

}

$netCompressionLevel = $this->configGroup->getPropertyInt(Yml::NETWORK_COMPRESSION_LEVEL, 6);

if($netCompressionLevel < 1 || $netCompressionLevel > 9){

$this->logger->warning("Invalid network compression level $netCompressionLevel set, setting to default 6");

$netCompressionLevel = 6;

}

ZlibCompressor::setInstance(new ZlibCompressor($netCompressionLevel, $netCompressionThreshold, ZlibCompressor::DEFAULT_MAX_DECOMPRESSION_SIZE));

$this->networkCompressionAsync = $this->configGroup->getPropertyBool(Yml::NETWORK_ASYNC_COMPRESSION, true);

$this->networkCompressionAsyncThreshold = max(

$this->configGroup->getPropertyInt(Yml::NETWORK_ASYNC_COMPRESSION_THRESHOLD, self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD),

$netCompressionThreshold ?? self::DEFAULT_ASYNC_COMPRESSION_THRESHOLD

);

EncryptionContext::$ENABLED = $this->configGroup->getPropertyBool(Yml::NETWORK_ENABLE_ENCRYPTION, true);

$this->doTitleTick = $this->configGroup->getPropertyBool(Yml::CONSOLE_TITLE_TICK, true) && Terminal::hasFormattingCodes();

$this->operators = new Config(Path::join($this->dataPath, "ops.txt"), Config::ENUM);

$this->whitelist = new Config(Path::join($this->dataPath, "white-list.txt"), Config::ENUM);

$bannedTxt = Path::join($this->dataPath, "banned.txt");

$bannedPlayersTxt = Path::join($this->dataPath, "banned-players.txt");

if(file_exists($bannedTxt) && !file_exists($bannedPlayersTxt)){

@rename($bannedTxt, $bannedPlayersTxt);

}

@touch($bannedPlayersTxt);

$this->banByName = new BanList($bannedPlayersTxt);

$this->banByName->load();

$bannedIpsTxt = Path::join($this->dataPath, "banned-ips.txt");

@touch($bannedIpsTxt);

$this->banByIP = new BanList($bannedIpsTxt);

$this->banByIP->load();

$this->maxPlayers = $this->configGroup->getConfigInt(ServerProperties::MAX_PLAYERS, self::DEFAULT_MAX_PLAYERS);

$this->onlineMode = $this->configGroup->getConfigBool(ServerProperties::XBOX_AUTH, true);

if($this->onlineMode){

$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_auth_enabled()));

}else{

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_auth_disabled()));

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_authWarning()));

$this->logger->warning($this->language->translate(KnownTranslationFactory::pocketmine_server_authProperty_disabled()));

}

if($this->configGroup->getConfigBool(ServerProperties::HARDCORE, false) && $this->getDifficulty() < World::DIFFICULTY_HARD){

$this->configGroup->setConfigInt(ServerProperties::DIFFICULTY, World::DIFFICULTY_HARD);

}

@cli_set_process_title($this->getName() . " " . $this->getPocketMineVersion());

$this->serverID = Utils::getMachineUniqueId($this->getIp() . $this->getPort());

$this->logger->debug("Server unique id: " . $this->getServerUniqueId());

$this->logger->debug("Machine unique id: " . Utils::getMachineUniqueId());

$this->network = new Network($this->logger);

$this->network->setName($this->getMotd());

$this->logger->info($this->language->translate(KnownTranslationFactory::pocketmine_server_info(

$this->getName(),