644 lines
20 KiB
Java
644 lines
20 KiB
Java
package net.minecraft.server.dedicated;
|
|
|
|
import com.google.common.collect.Lists;
|
|
import com.mojang.authlib.GameProfile;
|
|
import com.mojang.datafixers.DataFixer;
|
|
import com.mojang.logging.LogUtils;
|
|
import java.io.BufferedReader;
|
|
import java.io.IOException;
|
|
import java.io.InputStreamReader;
|
|
import java.io.Writer;
|
|
import java.net.InetAddress;
|
|
import java.net.Proxy;
|
|
import java.net.URI;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Optional;
|
|
import java.util.function.Supplier;
|
|
import net.minecraft.DefaultUncaughtExceptionHandler;
|
|
import net.minecraft.DefaultUncaughtExceptionHandlerWithName;
|
|
import net.minecraft.SharedConstants;
|
|
import net.minecraft.SystemReport;
|
|
import net.minecraft.Util;
|
|
import net.minecraft.commands.CommandSourceStack;
|
|
import net.minecraft.core.BlockPos;
|
|
import net.minecraft.server.ConsoleInput;
|
|
import net.minecraft.server.MinecraftServer;
|
|
import net.minecraft.server.ServerInterface;
|
|
import net.minecraft.server.ServerLinks;
|
|
import net.minecraft.server.Services;
|
|
import net.minecraft.server.WorldStem;
|
|
import net.minecraft.server.ServerLinks.KnownLinkType;
|
|
import net.minecraft.server.gui.MinecraftServerGui;
|
|
import net.minecraft.server.level.ServerLevel;
|
|
import net.minecraft.server.level.ServerPlayer;
|
|
import net.minecraft.server.level.progress.ChunkProgressListenerFactory;
|
|
import net.minecraft.server.network.ServerTextFilter;
|
|
import net.minecraft.server.network.TextFilter;
|
|
import net.minecraft.server.packs.repository.PackRepository;
|
|
import net.minecraft.server.players.GameProfileCache;
|
|
import net.minecraft.server.players.OldUsersConverter;
|
|
import net.minecraft.server.rcon.RconConsoleSource;
|
|
import net.minecraft.server.rcon.thread.QueryThreadGs4;
|
|
import net.minecraft.server.rcon.thread.RconThread;
|
|
import net.minecraft.util.Mth;
|
|
import net.minecraft.util.debugchart.DebugSampleSubscriptionTracker;
|
|
import net.minecraft.util.debugchart.RemoteDebugSampleType;
|
|
import net.minecraft.util.debugchart.RemoteSampleLogger;
|
|
import net.minecraft.util.debugchart.SampleLogger;
|
|
import net.minecraft.util.debugchart.TpsDebugDimensions;
|
|
import net.minecraft.util.monitoring.jmx.MinecraftServerStatistics;
|
|
import net.minecraft.world.entity.player.Player;
|
|
import net.minecraft.world.level.GameRules;
|
|
import net.minecraft.world.level.GameType;
|
|
import net.minecraft.world.level.Level;
|
|
import net.minecraft.world.level.block.entity.SkullBlockEntity;
|
|
import net.minecraft.world.level.storage.LevelStorageSource;
|
|
import org.jetbrains.annotations.Nullable;
|
|
import org.slf4j.Logger;
|
|
|
|
public class DedicatedServer extends MinecraftServer implements ServerInterface {
|
|
static final Logger LOGGER = LogUtils.getLogger();
|
|
private static final int CONVERSION_RETRY_DELAY_MS = 5000;
|
|
private static final int CONVERSION_RETRIES = 2;
|
|
private final List<ConsoleInput> consoleInput = Collections.synchronizedList(Lists.newArrayList());
|
|
@Nullable
|
|
private QueryThreadGs4 queryThreadGs4;
|
|
private final RconConsoleSource rconConsoleSource;
|
|
@Nullable
|
|
private RconThread rconThread;
|
|
private final DedicatedServerSettings settings;
|
|
@Nullable
|
|
private MinecraftServerGui gui;
|
|
@Nullable
|
|
private final ServerTextFilter serverTextFilter;
|
|
@Nullable
|
|
private RemoteSampleLogger tickTimeLogger;
|
|
@Nullable
|
|
private DebugSampleSubscriptionTracker debugSampleSubscriptionTracker;
|
|
private final ServerLinks serverLinks;
|
|
|
|
public DedicatedServer(
|
|
Thread serverThread,
|
|
LevelStorageSource.LevelStorageAccess storageSource,
|
|
PackRepository packRepository,
|
|
WorldStem worldStem,
|
|
DedicatedServerSettings settings,
|
|
DataFixer fixerUpper,
|
|
Services services,
|
|
ChunkProgressListenerFactory progressListenerFactory
|
|
) {
|
|
super(serverThread, storageSource, packRepository, worldStem, Proxy.NO_PROXY, fixerUpper, services, progressListenerFactory);
|
|
this.settings = settings;
|
|
this.rconConsoleSource = new RconConsoleSource(this);
|
|
this.serverTextFilter = ServerTextFilter.createFromConfig(settings.getProperties());
|
|
this.serverLinks = createServerLinks(settings);
|
|
}
|
|
|
|
@Override
|
|
public boolean initServer() throws IOException {
|
|
Thread thread = new Thread("Server console handler") {
|
|
public void run() {
|
|
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
|
|
|
|
String string;
|
|
try {
|
|
while (!DedicatedServer.this.isStopped() && DedicatedServer.this.isRunning() && (string = bufferedReader.readLine()) != null) {
|
|
DedicatedServer.this.handleConsoleInput(string, DedicatedServer.this.createCommandSourceStack());
|
|
}
|
|
} catch (IOException var4) {
|
|
DedicatedServer.LOGGER.error("Exception handling console input", (Throwable)var4);
|
|
}
|
|
}
|
|
};
|
|
thread.setDaemon(true);
|
|
thread.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandler(LOGGER));
|
|
thread.start();
|
|
LOGGER.info("Starting minecraft server version {}", SharedConstants.getCurrentVersion().getName());
|
|
if (Runtime.getRuntime().maxMemory() / 1024L / 1024L < 512L) {
|
|
LOGGER.warn("To start the server with more ram, launch it as \"java -Xmx1024M -Xms1024M -jar minecraft_server.jar\"");
|
|
}
|
|
|
|
LOGGER.info("Loading properties");
|
|
DedicatedServerProperties dedicatedServerProperties = this.settings.getProperties();
|
|
if (this.isSingleplayer()) {
|
|
this.setLocalIp("127.0.0.1");
|
|
} else {
|
|
this.setUsesAuthentication(dedicatedServerProperties.onlineMode);
|
|
this.setPreventProxyConnections(dedicatedServerProperties.preventProxyConnections);
|
|
this.setLocalIp(dedicatedServerProperties.serverIp);
|
|
}
|
|
|
|
this.setPvpAllowed(dedicatedServerProperties.pvp);
|
|
this.setFlightAllowed(dedicatedServerProperties.allowFlight);
|
|
this.setMotd(dedicatedServerProperties.motd);
|
|
super.setPlayerIdleTimeout(dedicatedServerProperties.playerIdleTimeout.get());
|
|
this.setEnforceWhitelist(dedicatedServerProperties.enforceWhitelist);
|
|
this.worldData.setGameType(dedicatedServerProperties.gamemode);
|
|
LOGGER.info("Default game type: {}", dedicatedServerProperties.gamemode);
|
|
InetAddress inetAddress = null;
|
|
if (!this.getLocalIp().isEmpty()) {
|
|
inetAddress = InetAddress.getByName(this.getLocalIp());
|
|
}
|
|
|
|
if (this.getPort() < 0) {
|
|
this.setPort(dedicatedServerProperties.serverPort);
|
|
}
|
|
|
|
this.initializeKeyPair();
|
|
LOGGER.info("Starting Minecraft server on {}:{}", this.getLocalIp().isEmpty() ? "*" : this.getLocalIp(), this.getPort());
|
|
|
|
try {
|
|
this.getConnection().startTcpServerListener(inetAddress, this.getPort());
|
|
} catch (IOException var10) {
|
|
LOGGER.warn("**** FAILED TO BIND TO PORT!");
|
|
LOGGER.warn("The exception was: {}", var10.toString());
|
|
LOGGER.warn("Perhaps a server is already running on that port?");
|
|
return false;
|
|
}
|
|
|
|
if (!this.usesAuthentication()) {
|
|
LOGGER.warn("**** SERVER IS RUNNING IN OFFLINE/INSECURE MODE!");
|
|
LOGGER.warn("The server will make no attempt to authenticate usernames. Beware.");
|
|
LOGGER.warn(
|
|
"While this makes the game possible to play without internet access, it also opens up the ability for hackers to connect with any username they choose."
|
|
);
|
|
LOGGER.warn("To change this, set \"online-mode\" to \"true\" in the server.properties file.");
|
|
}
|
|
|
|
if (this.convertOldUsers()) {
|
|
this.getProfileCache().save();
|
|
}
|
|
|
|
if (!OldUsersConverter.serverReadyAfterUserconversion(this)) {
|
|
return false;
|
|
} else {
|
|
this.setPlayerList(new DedicatedPlayerList(this, this.registries(), this.playerDataStorage));
|
|
this.debugSampleSubscriptionTracker = new DebugSampleSubscriptionTracker(this.getPlayerList());
|
|
this.tickTimeLogger = new RemoteSampleLogger(TpsDebugDimensions.values().length, this.debugSampleSubscriptionTracker, RemoteDebugSampleType.TICK_TIME);
|
|
long l = Util.getNanos();
|
|
SkullBlockEntity.setup(this.services, this);
|
|
GameProfileCache.setUsesAuthentication(this.usesAuthentication());
|
|
LOGGER.info("Preparing level \"{}\"", this.getLevelIdName());
|
|
this.loadLevel();
|
|
long m = Util.getNanos() - l;
|
|
String string = String.format(Locale.ROOT, "%.3fs", m / 1.0E9);
|
|
LOGGER.info("Done ({})! For help, type \"help\"", string);
|
|
if (dedicatedServerProperties.announcePlayerAchievements != null) {
|
|
this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS).set(dedicatedServerProperties.announcePlayerAchievements, this);
|
|
}
|
|
|
|
if (dedicatedServerProperties.enableQuery) {
|
|
LOGGER.info("Starting GS4 status listener");
|
|
this.queryThreadGs4 = QueryThreadGs4.create(this);
|
|
}
|
|
|
|
if (dedicatedServerProperties.enableRcon) {
|
|
LOGGER.info("Starting remote control listener");
|
|
this.rconThread = RconThread.create(this);
|
|
}
|
|
|
|
if (this.getMaxTickLength() > 0L) {
|
|
Thread thread2 = new Thread(new ServerWatchdog(this));
|
|
thread2.setUncaughtExceptionHandler(new DefaultUncaughtExceptionHandlerWithName(LOGGER));
|
|
thread2.setName("Server Watchdog");
|
|
thread2.setDaemon(true);
|
|
thread2.start();
|
|
}
|
|
|
|
if (dedicatedServerProperties.enableJmxMonitoring) {
|
|
MinecraftServerStatistics.registerJmxMonitoring(this);
|
|
LOGGER.info("JMX monitoring enabled");
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isSpawningMonsters() {
|
|
return this.settings.getProperties().spawnMonsters && super.isSpawningMonsters();
|
|
}
|
|
|
|
@Override
|
|
public DedicatedServerProperties getProperties() {
|
|
return this.settings.getProperties();
|
|
}
|
|
|
|
@Override
|
|
public void forceDifficulty() {
|
|
this.setDifficulty(this.getProperties().difficulty, true);
|
|
}
|
|
|
|
@Override
|
|
public SystemReport fillServerSystemReport(SystemReport report) {
|
|
report.setDetail("Is Modded", (Supplier<String>)(() -> this.getModdedStatus().fullDescription()));
|
|
report.setDetail("Type", (Supplier<String>)(() -> "Dedicated Server (map_server.txt)"));
|
|
return report;
|
|
}
|
|
|
|
@Override
|
|
public void dumpServerProperties(Path path) throws IOException {
|
|
DedicatedServerProperties dedicatedServerProperties = this.getProperties();
|
|
Writer writer = Files.newBufferedWriter(path);
|
|
|
|
try {
|
|
writer.write(String.format(Locale.ROOT, "sync-chunk-writes=%s%n", dedicatedServerProperties.syncChunkWrites));
|
|
writer.write(String.format(Locale.ROOT, "gamemode=%s%n", dedicatedServerProperties.gamemode));
|
|
writer.write(String.format(Locale.ROOT, "spawn-monsters=%s%n", dedicatedServerProperties.spawnMonsters));
|
|
writer.write(String.format(Locale.ROOT, "entity-broadcast-range-percentage=%d%n", dedicatedServerProperties.entityBroadcastRangePercentage));
|
|
writer.write(String.format(Locale.ROOT, "max-world-size=%d%n", dedicatedServerProperties.maxWorldSize));
|
|
writer.write(String.format(Locale.ROOT, "view-distance=%d%n", dedicatedServerProperties.viewDistance));
|
|
writer.write(String.format(Locale.ROOT, "simulation-distance=%d%n", dedicatedServerProperties.simulationDistance));
|
|
writer.write(String.format(Locale.ROOT, "generate-structures=%s%n", dedicatedServerProperties.worldOptions.generateStructures()));
|
|
writer.write(String.format(Locale.ROOT, "use-native=%s%n", dedicatedServerProperties.useNativeTransport));
|
|
writer.write(String.format(Locale.ROOT, "rate-limit=%d%n", dedicatedServerProperties.rateLimitPacketsPerSecond));
|
|
} catch (Throwable var7) {
|
|
if (writer != null) {
|
|
try {
|
|
writer.close();
|
|
} catch (Throwable var6) {
|
|
var7.addSuppressed(var6);
|
|
}
|
|
}
|
|
|
|
throw var7;
|
|
}
|
|
|
|
if (writer != null) {
|
|
writer.close();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onServerExit() {
|
|
if (this.serverTextFilter != null) {
|
|
this.serverTextFilter.close();
|
|
}
|
|
|
|
if (this.gui != null) {
|
|
this.gui.close();
|
|
}
|
|
|
|
if (this.rconThread != null) {
|
|
this.rconThread.stop();
|
|
}
|
|
|
|
if (this.queryThreadGs4 != null) {
|
|
this.queryThreadGs4.stop();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void tickConnection() {
|
|
super.tickConnection();
|
|
this.handleConsoleInputs();
|
|
}
|
|
|
|
@Override
|
|
public boolean isLevelEnabled(Level level) {
|
|
return level.dimension() == Level.NETHER ? this.getProperties().allowNether : true;
|
|
}
|
|
|
|
public void handleConsoleInput(String msg, CommandSourceStack source) {
|
|
this.consoleInput.add(new ConsoleInput(msg, source));
|
|
}
|
|
|
|
public void handleConsoleInputs() {
|
|
while (!this.consoleInput.isEmpty()) {
|
|
ConsoleInput consoleInput = (ConsoleInput)this.consoleInput.remove(0);
|
|
this.getCommands().performPrefixedCommand(consoleInput.source, consoleInput.msg);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean isDedicatedServer() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public int getRateLimitPacketsPerSecond() {
|
|
return this.getProperties().rateLimitPacketsPerSecond;
|
|
}
|
|
|
|
@Override
|
|
public boolean isEpollEnabled() {
|
|
return this.getProperties().useNativeTransport;
|
|
}
|
|
|
|
public DedicatedPlayerList getPlayerList() {
|
|
return (DedicatedPlayerList)super.getPlayerList();
|
|
}
|
|
|
|
@Override
|
|
public boolean isPublished() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public String getServerIp() {
|
|
return this.getLocalIp();
|
|
}
|
|
|
|
@Override
|
|
public int getServerPort() {
|
|
return this.getPort();
|
|
}
|
|
|
|
@Override
|
|
public String getServerName() {
|
|
return this.getMotd();
|
|
}
|
|
|
|
public void showGui() {
|
|
if (this.gui == null) {
|
|
this.gui = MinecraftServerGui.showFrameFor(this);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasGui() {
|
|
return this.gui != null;
|
|
}
|
|
|
|
@Override
|
|
public boolean isCommandBlockEnabled() {
|
|
return this.getProperties().enableCommandBlock;
|
|
}
|
|
|
|
@Override
|
|
public int getSpawnProtectionRadius() {
|
|
return this.getProperties().spawnProtection;
|
|
}
|
|
|
|
@Override
|
|
public boolean isUnderSpawnProtection(ServerLevel level, BlockPos pos, Player player) {
|
|
if (level.dimension() != Level.OVERWORLD) {
|
|
return false;
|
|
} else if (this.getPlayerList().getOps().isEmpty()) {
|
|
return false;
|
|
} else if (this.getPlayerList().isOp(player.getGameProfile())) {
|
|
return false;
|
|
} else if (this.getSpawnProtectionRadius() <= 0) {
|
|
return false;
|
|
} else {
|
|
BlockPos blockPos = level.getSharedSpawnPos();
|
|
int i = Mth.abs(pos.getX() - blockPos.getX());
|
|
int j = Mth.abs(pos.getZ() - blockPos.getZ());
|
|
int k = Math.max(i, j);
|
|
return k <= this.getSpawnProtectionRadius();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean repliesToStatus() {
|
|
return this.getProperties().enableStatus;
|
|
}
|
|
|
|
@Override
|
|
public boolean hidesOnlinePlayers() {
|
|
return this.getProperties().hideOnlinePlayers;
|
|
}
|
|
|
|
@Override
|
|
public int getOperatorUserPermissionLevel() {
|
|
return this.getProperties().opPermissionLevel;
|
|
}
|
|
|
|
@Override
|
|
public int getFunctionCompilationLevel() {
|
|
return this.getProperties().functionPermissionLevel;
|
|
}
|
|
|
|
@Override
|
|
public void setPlayerIdleTimeout(int idleTimeout) {
|
|
super.setPlayerIdleTimeout(idleTimeout);
|
|
this.settings
|
|
.update(dedicatedServerProperties -> (DedicatedServerProperties)dedicatedServerProperties.playerIdleTimeout.update(this.registryAccess(), idleTimeout));
|
|
}
|
|
|
|
@Override
|
|
public boolean shouldRconBroadcast() {
|
|
return this.getProperties().broadcastRconToOps;
|
|
}
|
|
|
|
@Override
|
|
public boolean shouldInformAdmins() {
|
|
return this.getProperties().broadcastConsoleToOps;
|
|
}
|
|
|
|
@Override
|
|
public int getAbsoluteMaxWorldSize() {
|
|
return this.getProperties().maxWorldSize;
|
|
}
|
|
|
|
@Override
|
|
public int getCompressionThreshold() {
|
|
return this.getProperties().networkCompressionThreshold;
|
|
}
|
|
|
|
@Override
|
|
public boolean enforceSecureProfile() {
|
|
DedicatedServerProperties dedicatedServerProperties = this.getProperties();
|
|
return dedicatedServerProperties.enforceSecureProfile && dedicatedServerProperties.onlineMode && this.services.canValidateProfileKeys();
|
|
}
|
|
|
|
@Override
|
|
public boolean logIPs() {
|
|
return this.getProperties().logIPs;
|
|
}
|
|
|
|
protected boolean convertOldUsers() {
|
|
boolean bl = false;
|
|
|
|
for (int i = 0; !bl && i <= 2; i++) {
|
|
if (i > 0) {
|
|
LOGGER.warn("Encountered a problem while converting the user banlist, retrying in a few seconds");
|
|
this.waitForRetry();
|
|
}
|
|
|
|
bl = OldUsersConverter.convertUserBanlist(this);
|
|
}
|
|
|
|
boolean bl2 = false;
|
|
|
|
for (int var7 = 0; !bl2 && var7 <= 2; var7++) {
|
|
if (var7 > 0) {
|
|
LOGGER.warn("Encountered a problem while converting the ip banlist, retrying in a few seconds");
|
|
this.waitForRetry();
|
|
}
|
|
|
|
bl2 = OldUsersConverter.convertIpBanlist(this);
|
|
}
|
|
|
|
boolean bl3 = false;
|
|
|
|
for (int var8 = 0; !bl3 && var8 <= 2; var8++) {
|
|
if (var8 > 0) {
|
|
LOGGER.warn("Encountered a problem while converting the op list, retrying in a few seconds");
|
|
this.waitForRetry();
|
|
}
|
|
|
|
bl3 = OldUsersConverter.convertOpsList(this);
|
|
}
|
|
|
|
boolean bl4 = false;
|
|
|
|
for (int var9 = 0; !bl4 && var9 <= 2; var9++) {
|
|
if (var9 > 0) {
|
|
LOGGER.warn("Encountered a problem while converting the whitelist, retrying in a few seconds");
|
|
this.waitForRetry();
|
|
}
|
|
|
|
bl4 = OldUsersConverter.convertWhiteList(this);
|
|
}
|
|
|
|
boolean bl5 = false;
|
|
|
|
for (int var10 = 0; !bl5 && var10 <= 2; var10++) {
|
|
if (var10 > 0) {
|
|
LOGGER.warn("Encountered a problem while converting the player save files, retrying in a few seconds");
|
|
this.waitForRetry();
|
|
}
|
|
|
|
bl5 = OldUsersConverter.convertPlayers(this);
|
|
}
|
|
|
|
return bl || bl2 || bl3 || bl4 || bl5;
|
|
}
|
|
|
|
private void waitForRetry() {
|
|
try {
|
|
Thread.sleep(5000L);
|
|
} catch (InterruptedException var2) {
|
|
}
|
|
}
|
|
|
|
public long getMaxTickLength() {
|
|
return this.getProperties().maxTickTime;
|
|
}
|
|
|
|
@Override
|
|
public int getMaxChainedNeighborUpdates() {
|
|
return this.getProperties().maxChainedNeighborUpdates;
|
|
}
|
|
|
|
@Override
|
|
public String getPluginNames() {
|
|
return "";
|
|
}
|
|
|
|
@Override
|
|
public String runCommand(String command) {
|
|
this.rconConsoleSource.prepareForCommand();
|
|
this.executeBlocking(() -> this.getCommands().performPrefixedCommand(this.rconConsoleSource.createCommandSourceStack(), command));
|
|
return this.rconConsoleSource.getCommandResponse();
|
|
}
|
|
|
|
public void storeUsingWhiteList(boolean isStoreUsingWhiteList) {
|
|
this.settings
|
|
.update(dedicatedServerProperties -> (DedicatedServerProperties)dedicatedServerProperties.whiteList.update(this.registryAccess(), isStoreUsingWhiteList));
|
|
}
|
|
|
|
@Override
|
|
public void stopServer() {
|
|
super.stopServer();
|
|
Util.shutdownExecutors();
|
|
SkullBlockEntity.clear();
|
|
}
|
|
|
|
@Override
|
|
public boolean isSingleplayerOwner(GameProfile profile) {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public int getScaledTrackingDistance(int trackingDistance) {
|
|
return this.getProperties().entityBroadcastRangePercentage * trackingDistance / 100;
|
|
}
|
|
|
|
@Override
|
|
public String getLevelIdName() {
|
|
return this.storageSource.getLevelId();
|
|
}
|
|
|
|
@Override
|
|
public boolean forceSynchronousWrites() {
|
|
return this.settings.getProperties().syncChunkWrites;
|
|
}
|
|
|
|
@Override
|
|
public TextFilter createTextFilterForPlayer(ServerPlayer player) {
|
|
return this.serverTextFilter != null ? this.serverTextFilter.createContext(player.getGameProfile()) : TextFilter.DUMMY;
|
|
}
|
|
|
|
@Nullable
|
|
@Override
|
|
public GameType getForcedGameType() {
|
|
return this.settings.getProperties().forceGameMode ? this.worldData.getGameType() : null;
|
|
}
|
|
|
|
@Override
|
|
public Optional<MinecraftServer.ServerResourcePackInfo> getServerResourcePack() {
|
|
return this.settings.getProperties().serverResourcePackInfo;
|
|
}
|
|
|
|
@Override
|
|
public void endMetricsRecordingTick() {
|
|
super.endMetricsRecordingTick();
|
|
this.debugSampleSubscriptionTracker.tick(this.getTickCount());
|
|
}
|
|
|
|
@Override
|
|
public SampleLogger getTickTimeLogger() {
|
|
return this.tickTimeLogger;
|
|
}
|
|
|
|
@Override
|
|
public boolean isTickTimeLoggingEnabled() {
|
|
return this.debugSampleSubscriptionTracker.shouldLogSamples(RemoteDebugSampleType.TICK_TIME);
|
|
}
|
|
|
|
@Override
|
|
public void subscribeToDebugSample(ServerPlayer player, RemoteDebugSampleType sampleType) {
|
|
this.debugSampleSubscriptionTracker.subscribe(player, sampleType);
|
|
}
|
|
|
|
@Override
|
|
public boolean acceptsTransfers() {
|
|
return this.settings.getProperties().acceptsTransfers;
|
|
}
|
|
|
|
@Override
|
|
public ServerLinks serverLinks() {
|
|
return this.serverLinks;
|
|
}
|
|
|
|
@Override
|
|
public int pauseWhileEmptySeconds() {
|
|
return this.settings.getProperties().pauseWhenEmptySeconds;
|
|
}
|
|
|
|
private static ServerLinks createServerLinks(DedicatedServerSettings settings) {
|
|
Optional<URI> optional = parseBugReportLink(settings.getProperties());
|
|
return (ServerLinks)optional.map(uRI -> new ServerLinks(List.of(KnownLinkType.BUG_REPORT.create(uRI)))).orElse(ServerLinks.EMPTY);
|
|
}
|
|
|
|
private static Optional<URI> parseBugReportLink(DedicatedServerProperties properties) {
|
|
String string = properties.bugReportLink;
|
|
if (string.isEmpty()) {
|
|
return Optional.empty();
|
|
} else {
|
|
try {
|
|
return Optional.of(Util.parseAndValidateUntrustedUri(string));
|
|
} catch (Exception var3) {
|
|
LOGGER.warn("Failed to parse bug link {}", string, var3);
|
|
return Optional.empty();
|
|
}
|
|
}
|
|
}
|
|
}
|