class="kw">package com.hypixel.hytale.server.core.universe.world;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.ObjectMapCodec;
class="kw">import com.hypixel.hytale.codec.codecs.set.SetCodec;
class="kw">import com.hypixel.hytale.codec.lookup.MapKeyMapCodec;
class="kw">import com.hypixel.hytale.codec.schema.metadata.NoDefaultValue;
class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.common.plugin.PluginIdentifier;
class="kw">import com.hypixel.hytale.common.semver.SemverRange;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.shape.Box2D;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.MutableDeathConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
class="kw">import com.hypixel.hytale.server.core.codec.ProtocolCodecs;
class="kw">import com.hypixel.hytale.server.core.codec.ShapeCodecs;
class="kw">import com.hypixel.hytale.server.core.config.CrashRecoveryConfig;
class="kw">import com.hypixel.hytale.server.core.config.WorldWorldMapConfig;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.GlobalSpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.ISpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.IChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.resources.IResourceStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.IWorldGen;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.provider.IWorldMapProvider;
class="kw">import com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import java.nio.file.Path;
class="kw">import java.time.Instant;
class="kw">import java.time.temporal.ChronoUnit;
class="kw">import java.util.Collections;
class="kw">import java.util.HashMap;
class="kw">import java.util.HashSet;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.atomic.AtomicBoolean;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonDocument;
class="kw">import org.joml.Vector2d;

class="kw">public class WorldConfig {
   class="kw">public class="kw">static class="kw">final int VERSION = 4;
   class="kw">public class="kw">static class="kw">final int INITIAL_GAME_DAY_START_HOUR = 5;
   class="kw">public class="kw">static class="kw">final int INITIAL_GAME_DAY_START_MINS = 30;
   class="kw">public class="kw">static class="kw">final MapKeyMapCodec<Object> PLUGIN_CODEC = new MapKeyMapCodec<>(false);
   class="kw">public class="kw">static class="kw">final BuilderCodec<WorldConfig> CODEC = BuilderCodec.<WorldConfig>builder(WorldConfig.class, () -> new WorldConfig(null))
      .versioned()
      .codecVersion(4)
      .documentation(
         "Configuration for a single world. Settings in here only affect the world this configuration belongs to.\n\nInstances share this configuration but ignore certain parameters (e.g. *UUID*). In this case the configuration willbe cloned before loading the instance."
      )
      .<UUID>append(new KeyedCodec<>("UUID", Codec.UUID_BINARY), (var0, var1) -> var0.uuid = var1, var0 -> var0.uuid)
      .documentation(
         "The unique identifier for this world.\n\nInstances will ignore this and replace it with a freshly generated UUID when spawning the instance."
      )
      .add()
      .<String>append(new KeyedCodec<>("DisplayName", Codec.STRING), (var0, var1) -> var0.displayName = var1, var0 -> var0.displayName)
      .documentation("The player facing name of this world.")
      .add()
      .<Long>append(new KeyedCodec<>("Seed", Codec.LONG), (var0, var1) -> var0.seed = var1, var0 -> var0.seed)
      .documentation("The seed of the world, used for world generation.\n\nIf a seed is not set then one will be randomly generated.")
      .metadata(NoDefaultValue.INSTANCE)
      .add()
      .<Transform>append(new KeyedCodec<>("SpawnPoint", Transform.CODEC), (var0, var1) -> var0.spawnProvider = new GlobalSpawnProvider(var1), var0 -> null)
      .documentation("**Deprecated**: Please use **SpawnProvider** instead.")
      .setVersionRange(0, 1)
      .add()
      .<ISpawnProvider>append(new KeyedCodec<>("SpawnProvider", ISpawnProvider.CODEC), (var0, var1) -> var0.spawnProvider = var1, var0 -> var0.spawnProvider)
      .documentation(
         "Sets the spawn provider for the world. \n\nThis controls where new players will enter the world at. This can be provided by world generation in some cases."
      )
      .add()
      .<IWorldGenProvider>append(
         new KeyedCodec<>("WorldGen", IWorldGenProvider.CODEC), (var0, var1) -> var0.worldGenProvider = var1, var0 -> var0.worldGenProvider
      )
      .documentation("Sets the world generator that will be used by the world.")
      .add()
      .append(new KeyedCodec<>("WorldMap", IWorldMapProvider.CODEC), (var0, var1) -> var0.worldMapProvider = var1, var0 -> var0.worldMapProvider)
      .add()
      .<WorldWorldMapConfig>append(
         new KeyedCodec<>("WorldMapConfig", WorldWorldMapConfig.CODEC), (var0, var1) -> var0.worldMapConfig = var1, var0 -> var0.worldMapConfig
      )
      .documentation("Optional per-world overrides for world map configuration and limits.")
      .add()
      .<IChunkStorageProvider<?>>append(
         new KeyedCodec<>("ChunkStorage", IChunkStorageProvider.CODEC), (var0, var1) -> var0.chunkStorageProvider = var1, var0 -> var0.chunkStorageProvider
      )
      .documentation("Sets the storage system that will be used by the world to store chunks.")
      .add()
      .<WorldConfig.ChunkConfig>append(
         new KeyedCodec<>("ChunkConfig", WorldConfig.ChunkConfig.CODEC), (var0, var1) -> var0.chunkConfig = var1, var0 -> var0.chunkConfig
      )
      .documentation("Configuration for chunk related settings")
      .addValidator(Validators.nonNull())
      .add()
      .<Boolean>append(new KeyedCodec<>("IsTicking", Codec.BOOLEAN), (var0, var1) -> var0.isTicking = var1, var0 -> var0.isTicking)
      .documentation("Sets whether chunks in this world are ticking or not.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsBlockTicking", Codec.BOOLEAN), (var0, var1) -> var0.isBlockTicking = var1, var0 -> var0.isBlockTicking)
      .documentation("Sets whether blocks in this world are ticking or not.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsPvpEnabled", Codec.BOOLEAN), (var0, var1) -> var0.isPvpEnabled = var1, var0 -> var0.isPvpEnabled)
      .documentation("Sets whether PvP is allowed in this world or not.")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("IsFallDamageEnabled", Codec.BOOLEAN), (var0, var1) -> var0.isFallDamageEnabled = var1, var0 -> var0.isFallDamageEnabled
      )
      .documentation("Sets whether fall damage is allowed in this world or not.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsGameTimePaused", Codec.BOOLEAN), (var0, var1) -> var0.isGameTimePaused = var1, var0 -> var0.isGameTimePaused)
      .documentation("Sets whether the game time is paused.\n\nThis effects things like day/night cycles and things that rely on those.")
      .add()
      .<Instant>append(new KeyedCodec<>("GameTime", Codec.INSTANT), (var0, var1) -> var0.gameTime = var1, var0 -> var0.gameTime)
      .documentation("The current time of day in the world.")
      .add()
      .<String>append(new KeyedCodec<>("ForcedWeather", Codec.STRING), (var0, var1) -> var0.forcedWeather = var1, var0 -> var0.forcedWeather)
      .documentation("Sets the type of weather that is being forced to be active in this world.")
      .addValidator(Weather.VALIDATOR_CACHE.getValidator())
      .add()
      .<ClientEffectWorldSettings>append(
         new KeyedCodec<>("ClientEffects", ClientEffectWorldSettings.CODEC), (var0, var1) -> var0.clientEffects = var1, var0 -> var0.clientEffects
      )
      .documentation("Settings for the client's weather and post-processing effects in this world.")
      .add()
      .<Box>append(
         new KeyedCodec<>("PregenerateRegion", ShapeCodecs.BOX),
         (var0, var1) -> var0.chunkConfig.setPregenerateRegion(new Box2D(new Vector2d(var1.min.x, var1.min.z), new Vector2d(var1.max.x, var1.max.z))),
         var0 -> null
      )
      .setVersionRange(1, 3)
      .addValidator(Validators.deprecated())
      .add()
      .<Map>append(
         new KeyedCodec<>(
            "RequiredPlugins", new ObjectMapCodec<>(SemverRange.CODEC, HashMap::new, PluginIdentifier::toString, PluginIdentifier::fromString, false)
         ),
         (var0, var1) -> var0.requiredPlugins = var1,
         var0 -> var0.requiredPlugins
      )
      .documentation("Sets the plugins that are required to be enabled for this world to function.")
      .add()
      .<GameMode>append(new KeyedCodec<>("GameMode", ProtocolCodecs.GAMEMODE), (var0, var1) -> var0.gameMode = var1, var0 -> var0.gameMode)
      .documentation("Sets the class="kw">default gamemode for this world.")
      .add()
      .<String>append(
         new KeyedCodec<>("DefaultPermissionGroup", Codec.STRING), (var0, var1) -> var0.defaultPermissionGroup = var1, var0 -> var0.defaultPermissionGroup
      )
      .documentation("The class="kw">default permission group assigned to new players joining this world.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsSpawningNPC", Codec.BOOLEAN), (var0, var1) -> var0.isSpawningNPC = var1, var0 -> var0.isSpawningNPC)
      .documentation("Whether NPCs can spawn in this world or not.")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("IsBlockSpawnersEnabled", Codec.BOOLEAN), (var0, var1) -> var0.isBlockSpawnersResolved = var1, var0 -> var0.isBlockSpawnersResolved
      )
      .documentation("Whether block spawners resolve into their target blocks in this world.")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("IsSpawnMarkersEnabled", Codec.BOOLEAN), (var0, var1) -> var0.isSpawnMarkersEnabled = var1, var0 -> var0.isSpawnMarkersEnabled
      )
      .documentation("Whether spawn markers are enabled for this world.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsAllNPCFrozen", Codec.BOOLEAN), (var0, var1) -> var0.isAllNPCFrozen = var1, var0 -> var0.isAllNPCFrozen)
      .documentation("Whether all NPCs are frozen for this world")
      .add()
      .<String>append(new KeyedCodec<>("GameplayConfig", Codec.STRING), (var0, var1) -> var0.gameplayConfig = var1, var0 -> var0.gameplayConfig)
      .addValidator(GameplayConfig.VALIDATOR_CACHE.getValidator())
      .documentation("The gameplay configuration being used by this world")
      .add()
      .<MutableDeathConfig>append(
         new KeyedCodec<>("Death", MutableDeathConfig.CODEC), (var0, var1) -> var0.deathConfigOverride = var1, var0 -> var0.deathConfigOverride
      )
      .documentation("Inline death configuration overrides for this world. If set, these values take precedence over the referenced GameplayConfig.")
      .add()
      .<Integer>append(
         new KeyedCodec<>("DaytimeDurationSeconds", Codec.INTEGER),
         (var0, var1) -> var0.daytimeDurationSecondsOverride = var1,
         var0 -> var0.daytimeDurationSecondsOverride
      )
      .documentation("Override for the duration of daytime in seconds. If set, takes precedence over the referenced GameplayConfig.")
      .add()
      .<Integer>append(
         new KeyedCodec<>("NighttimeDurationSeconds", Codec.INTEGER),
         (var0, var1) -> var0.nighttimeDurationSecondsOverride = var1,
         var0 -> var0.nighttimeDurationSecondsOverride
      )
      .documentation("Override for the duration of nighttime in seconds. If set, takes precedence over the referenced GameplayConfig.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsCompassUpdating", Codec.BOOLEAN), (var0, var1) -> var0.isCompassUpdating = var1, var0 -> var0.isCompassUpdating)
      .documentation("Whether the compass is updating in this world")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsSavingPlayers", Codec.BOOLEAN), (var0, var1) -> var0.isSavingPlayers = var1, var0 -> var0.isSavingPlayers)
      .documentation("Whether the configuration for player's is being saved for players in this world.")
      .add()
      .<Boolean>append(new KeyedCodec<>("IsSavingChunks", Codec.BOOLEAN), (var0, var1) -> var0.canSaveChunks = var1, var0 -> var0.canSaveChunks)
      .documentation("Whether the chunk data is allowed to be saved to the disk for this world.")
      .add()
      .<Boolean>append(new KeyedCodec<>("SaveNewChunks", Codec.BOOLEAN), (var0, var1) -> var0.saveNewChunks = var1, var0 -> var0.saveNewChunks)
      .documentation(
         "Whether newly generated chunks should be marked for saving or not.\nEnabling this can prevent random chunks from being out of place if/when worldgen changes but will increase the size of the world on disk."
      )
      .add()
      .<Boolean>append(new KeyedCodec<>("IsUnloadingChunks", Codec.BOOLEAN), (var0, var1) -> var0.canUnloadChunks = var1, var0 -> var0.canUnloadChunks)
      .documentation("Whether the chunks should be unloaded like normally, or should be prevented from unloading at all.")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("IsObjectiveMarkersEnabled", Codec.BOOLEAN),
         (var0, var1) -> var0.isObjectiveMarkersEnabled = var1,
         var0 -> var0.isObjectiveMarkersEnabled
      )
      .documentation("Whether objective markers are enabled for this world.")
      .add()
      .<Boolean>append(
         new KeyedCodec<>("DeleteOnUniverseStart", Codec.BOOLEAN), (var0, var1) -> var0.deleteOnUniverseStart = var1, var0 -> var0.deleteOnUniverseStart
      )
      .documentation(
         "Whether this world should be deleted when loaded from Universe start. By class="kw">default this is when going through the world folders in the universe directory."
      )
      .add()
      .<Boolean>append(new KeyedCodec<>("DeleteOnRemove", Codec.BOOLEAN), (var0, var1) -> var0.deleteOnRemove = var1, var0 -> var0.deleteOnRemove)
      .documentation("Whether this world should be deleted once its been removed from the server")
      .add()
      .<CrashRecoveryConfig>append(
         new KeyedCodec<>("CrashRecovery", CrashRecoveryConfig.CODEC), (var0, var1) -> var0.crashRecovery = var1, var0 -> var0.crashRecovery
      )
      .documentation("Recovery policy for this world when its thread crashes. Overrides the server class="kw">default.")
      .add()
      .<BsonDocument>append(
         new KeyedCodec<>("Instance", Codec.BSON_DOCUMENT),
         (var0, var1, var2) -> var0.pluginConfig.put(PLUGIN_CODEC.getKeyForId("Instance"), PLUGIN_CODEC.decodeById("Instance", var1, var2)),
         (var0, var1) -> null
      )
      .setVersionRange(0, 2)
      .documentation("Instance specific configuration.")
      .addValidator(Validators.deprecated())
      .add()
      .<Set>append(
         new KeyedCodec<>("DisabledFluidTickers", new SetCodec<>(Codec.STRING, HashSet::new, false)),
         (var0, var1) -> var0.disabledFluidTickers = var1,
         var0 -> var0.disabledFluidTickers
      )
      .documentation(
         "A set of fluid tag strings (e.g. \"Fluid=Water\", \"Fire=Fire\") whose tickers should be disabled in this world. Fluids matching any of these tags will not tick."
      )
      .add()
      .<IResourceStorageProvider>append(
         new KeyedCodec<>("ResourceStorage", IResourceStorageProvider.CODEC),
         (var0, var1) -> var0.resourceStorageProvider = var1,
         var0 -> var0.resourceStorageProvider
      )
      .documentation("Sets the storage system that will be used to store resources.")
      .add()
      .<MapKeyMapCodec.TypeMap<Object>>appendInherited(new KeyedCodec<>("Plugin", PLUGIN_CODEC), (var0, var1) -> {
         if (var0.pluginConfig.isEmpty()) {
            var0.pluginConfig = var1;
         } else {
            MapKeyMapCodec.TypeMap var2 = var0.pluginConfig;
            var0.pluginConfig.putAll(var2);
            var0.pluginConfig.putAll(var1);
         }
      }, var0 -> var0.pluginConfig, (var0, var1) -> var0.pluginConfig = var1.pluginConfig)
      .addValidator(Validators.nonNull())
      .add()
      .build();
   @Nonnull
   class="kw">private class="kw">final class="kw">transient AtomicBoolean hasChanged = new AtomicBoolean();
   class="kw">private UUID uuid = UUID.randomUUID();
   class="kw">private String displayName;
   class="kw">private long seed = System.currentTimeMillis();
   @Nullable
   class="kw">private ISpawnProvider spawnProvider = null;
   class="kw">private IWorldGenProvider worldGenProvider = IWorldGenProvider.CODEC.getDefault();
   class="kw">private IWorldMapProvider worldMapProvider = IWorldMapProvider.CODEC.getDefault();
   @Nullable
   class="kw">private WorldWorldMapConfig worldMapConfig;
   class="kw">private IChunkStorageProvider<?> chunkStorageProvider = IChunkStorageProvider.CODEC.getDefault();
   @Nonnull
   class="kw">private WorldConfig.ChunkConfig chunkConfig = new WorldConfig.ChunkConfig();
   class="kw">private boolean isTicking = true;
   class="kw">private boolean isBlockTicking = true;
   class="kw">private boolean isPvpEnabled = false;
   class="kw">private boolean isFallDamageEnabled = true;
   class="kw">private boolean isGameTimePaused = false;
   class="kw">private Instant gameTime = WorldTimeResource.ZERO_YEAR.plus(5L, ChronoUnit.HOURS).plus(30L, ChronoUnit.MINUTES);
   class="kw">private String forcedWeather;
   class="kw">private ClientEffectWorldSettings clientEffects = new ClientEffectWorldSettings();
   class="kw">private Map<PluginIdentifier, SemverRange> requiredPlugins = Collections.emptyMap();
   class="kw">private GameMode gameMode;
   @Nullable
   class="kw">private String defaultPermissionGroup;
   class="kw">private boolean isSpawningNPC = true;
   class="kw">private boolean isBlockSpawnersResolved = true;
   class="kw">private boolean isSpawnMarkersEnabled = true;
   class="kw">private boolean isAllNPCFrozen = false;
   class="kw">private String gameplayConfig = "Default";
   @Nullable
   class="kw">private MutableDeathConfig deathConfigOverride = null;
   @Nullable
   class="kw">private Integer daytimeDurationSecondsOverride = null;
   @Nullable
   class="kw">private Integer nighttimeDurationSecondsOverride = null;
   class="kw">private boolean isCompassUpdating = true;
   class="kw">private boolean isSavingPlayers = true;
   class="kw">private boolean canSaveChunks = true;
   class="kw">private boolean saveNewChunks = true;
   class="kw">private boolean canUnloadChunks = true;
   class="kw">private boolean isObjectiveMarkersEnabled = true;
   class="kw">private boolean deleteOnUniverseStart = false;
   class="kw">private boolean deleteOnRemove = false;
   @Nullable
   class="kw">private CrashRecoveryConfig crashRecovery;
   @Nonnull
   class="kw">private Set<String> disabledFluidTickers = Collections.emptySet();
   class="kw">private IResourceStorageProvider resourceStorageProvider = IResourceStorageProvider.CODEC.getDefault();
   class="kw">protected MapKeyMapCodec.TypeMap<Object> pluginConfig = new MapKeyMapCodec.TypeMap<>(PLUGIN_CODEC);
   @Nullable
   class="kw">private class="kw">transient ISpawnProvider defaultSpawnProvider;
   class="kw">private class="kw">transient boolean isSavingConfig = true;

   class="kw">public WorldConfig() {
      this.markChanged();
   }

   class="kw">private WorldConfig(Void var1) {
   }

   @Nonnull
   class="kw">public UUID getUuid() {
      class="kw">return this.uuid;
   }

   class="kw">public void setUuid(UUID var1) {
      this.uuid = var1;
   }

   class="kw">public boolean isDeleteOnUniverseStart() {
      class="kw">return this.deleteOnUniverseStart;
   }

   class="kw">public void setDeleteOnUniverseStart(boolean var1) {
      this.deleteOnUniverseStart = var1;
   }

   class="kw">public boolean isDeleteOnRemove() {
      class="kw">return this.deleteOnRemove;
   }

   class="kw">public void setDeleteOnRemove(boolean var1) {
      this.deleteOnRemove = var1;
   }

   @Nullable
   class="kw">public CrashRecoveryConfig getCrashRecovery() {
      class="kw">return this.crashRecovery;
   }

   class="kw">public void setCrashRecovery(@Nullable CrashRecoveryConfig var1) {
      this.crashRecovery = var1;
   }

   class="kw">public boolean isSavingConfig() {
      class="kw">return this.isSavingConfig;
   }

   class="kw">public void setSavingConfig(boolean var1) {
      this.isSavingConfig = var1;
   }

   class="kw">public String getDisplayName() {
      class="kw">return this.displayName;
   }

   class="kw">public void setDisplayName(String var1) {
      this.displayName = var1;
   }

   @Nonnull
   class="kw">public class="kw">static String formatDisplayName(@Nonnull String var0) {
      int var1 = var0.lastIndexOf(47);
      String var2 = var1 >= 0 ? var0.substring(var1 + 1) : var0;
      class="kw">return var2.replaceAll("([a-z])([A-Z])", "$1 $2").replaceAll("([A-Za-z])([0-9])", "$1 $2").replaceAll("_", " ");
   }

   class="kw">public long getSeed() {
      class="kw">return this.seed;
   }

   class="kw">public void setSeed(long var1) {
      this.seed = var1;
   }

   @Nullable
   class="kw">public ISpawnProvider getSpawnProvider() {
      class="kw">return this.spawnProvider != null ? this.spawnProvider : this.defaultSpawnProvider;
   }

   class="kw">public void setSpawnProvider(ISpawnProvider var1) {
      this.spawnProvider = var1;
   }

   class="kw">public void setDefaultSpawnProvider(@Nonnull IWorldGen var1) {
      this.defaultSpawnProvider = var1.getDefaultSpawnProvider((int)this.seed);
   }

   class="kw">public IWorldGenProvider getWorldGenProvider() {
      class="kw">return this.worldGenProvider;
   }

   class="kw">public void setWorldGenProvider(IWorldGenProvider var1) {
      this.worldGenProvider = var1;
   }

   class="kw">public IWorldMapProvider getWorldMapProvider() {
      class="kw">return this.worldMapProvider;
   }

   class="kw">public void setWorldMapProvider(IWorldMapProvider var1) {
      this.worldMapProvider = var1;
   }

   @Nullable
   class="kw">public WorldWorldMapConfig getWorldMapConfig() {
      class="kw">return this.worldMapConfig;
   }

   class="kw">public void setWorldMapConfig(@Nullable WorldWorldMapConfig var1) {
      this.worldMapConfig = var1;
      this.markChanged();
   }

   class="kw">public IChunkStorageProvider<?> getChunkStorageProvider() {
      class="kw">return this.chunkStorageProvider;
   }

   class="kw">public void setChunkStorageProvider(IChunkStorageProvider<?> var1) {
      this.chunkStorageProvider = var1;
   }

   @Nonnull
   class="kw">public WorldConfig.ChunkConfig getChunkConfig() {
      class="kw">return this.chunkConfig;
   }

   class="kw">public void setChunkConfig(@Nonnull WorldConfig.ChunkConfig var1) {
      this.chunkConfig = var1;
   }

   class="kw">public boolean isTicking() {
      class="kw">return this.isTicking;
   }

   class="kw">public void setTicking(boolean var1) {
      this.isTicking = var1;
   }

   class="kw">public boolean isBlockTicking() {
      class="kw">return this.isBlockTicking;
   }

   class="kw">public void setBlockTicking(boolean var1) {
      this.isBlockTicking = var1;
   }

   class="kw">public boolean isPvpEnabled() {
      class="kw">return this.isPvpEnabled;
   }

   class="kw">public void setPvpEnabled(boolean var1) {
      this.isPvpEnabled = var1;
   }

   class="kw">public boolean isFallDamageEnabled() {
      class="kw">return this.isFallDamageEnabled;
   }

   class="kw">public void setFallDamageEnabled(boolean var1) {
      this.isFallDamageEnabled = var1;
   }

   class="kw">public boolean isGameTimePaused() {
      class="kw">return this.isGameTimePaused;
   }

   class="kw">public void setGameTimePaused(boolean var1) {
      this.isGameTimePaused = var1;
   }

   class="kw">public Instant getGameTime() {
      class="kw">return this.gameTime;
   }

   class="kw">public void setGameTime(Instant var1) {
      this.gameTime = var1;
   }

   class="kw">public String getForcedWeather() {
      class="kw">return this.forcedWeather;
   }

   class="kw">public void setForcedWeather(String var1) {
      this.forcedWeather = var1;
   }

   class="kw">public void setClientEffects(ClientEffectWorldSettings var1) {
      this.clientEffects = var1;
   }

   class="kw">public ClientEffectWorldSettings getClientEffects() {
      class="kw">return this.clientEffects;
   }

   @Nonnull
   class="kw">public Map<PluginIdentifier, SemverRange> getRequiredPlugins() {
      class="kw">return Collections.unmodifiableMap(this.requiredPlugins);
   }

   class="kw">public void setRequiredPlugins(Map<PluginIdentifier, SemverRange> var1) {
      this.requiredPlugins = var1;
   }

   class="kw">public GameMode getGameMode() {
      class="kw">return this.gameMode != null ? this.gameMode : HytaleServer.get().getConfig().getDefaults().getGameMode();
   }

   class="kw">public void setGameMode(GameMode var1) {
      this.gameMode = var1;
   }

   @Nonnull
   class="kw">public String getDefaultPermissionGroup() {
      class="kw">return this.defaultPermissionGroup != null ? this.defaultPermissionGroup : "hytale:Adventurer";
   }

   class="kw">public void setDefaultPermissionGroup(@Nullable String var1) {
      this.defaultPermissionGroup = var1;
   }

   class="kw">public boolean isSpawningNPC() {
      class="kw">return this.isSpawningNPC;
   }

   class="kw">public void setSpawningNPC(boolean var1) {
      this.isSpawningNPC = var1;
   }

   class="kw">public boolean isBlockSpawnersResolved() {
      class="kw">return this.isBlockSpawnersResolved;
   }

   class="kw">public void setBlockSpawnersResolved(boolean var1) {
      this.isBlockSpawnersResolved = var1;
   }

   class="kw">public boolean isSpawnMarkersEnabled() {
      class="kw">return this.isSpawnMarkersEnabled;
   }

   class="kw">public void setIsSpawnMarkersEnabled(boolean var1) {
      this.isSpawnMarkersEnabled = var1;
   }

   class="kw">public boolean isAllNPCFrozen() {
      class="kw">return this.isAllNPCFrozen;
   }

   class="kw">public void setIsAllNPCFrozen(boolean var1) {
      this.isAllNPCFrozen = var1;
   }

   class="kw">public String getGameplayConfig() {
      class="kw">return this.gameplayConfig;
   }

   class="kw">public void setGameplayConfig(String var1) {
      this.gameplayConfig = var1;
   }

   @Nullable
   class="kw">public MutableDeathConfig getDeathConfigOverride() {
      class="kw">return this.deathConfigOverride;
   }

   class="kw">public void setDeathConfigOverride(@Nullable MutableDeathConfig var1) {
      this.deathConfigOverride = var1;
      this.markChanged();
   }

   @Nullable
   class="kw">public Integer getDaytimeDurationSecondsOverride() {
      class="kw">return this.daytimeDurationSecondsOverride;
   }

   @Nullable
   class="kw">public Integer getNighttimeDurationSecondsOverride() {
      class="kw">return this.nighttimeDurationSecondsOverride;
   }

   class="kw">public boolean isCompassUpdating() {
      class="kw">return this.isCompassUpdating;
   }

   class="kw">public void setCompassUpdating(boolean var1) {
      this.isCompassUpdating = var1;
   }

   class="kw">public boolean isSavingPlayers() {
      class="kw">return this.isSavingPlayers;
   }

   class="kw">public void setSavingPlayers(boolean var1) {
      this.isSavingPlayers = var1;
   }

   class="kw">public boolean canUnloadChunks() {
      class="kw">return this.canUnloadChunks;
   }

   class="kw">public void setCanUnloadChunks(boolean var1) {
      this.canUnloadChunks = var1;
   }

   class="kw">public boolean canSaveChunks() {
      class="kw">return this.canSaveChunks;
   }

   class="kw">public void setCanSaveChunks(boolean var1) {
      this.canSaveChunks = var1;
   }

   class="kw">public boolean shouldSaveNewChunks() {
      class="kw">return this.saveNewChunks;
   }

   class="kw">public void setSaveNewChunks(boolean var1) {
      this.saveNewChunks = var1;
   }

   class="kw">public boolean isObjectiveMarkersEnabled() {
      class="kw">return this.isObjectiveMarkersEnabled;
   }

   class="kw">public void setObjectiveMarkersEnabled(boolean var1) {
      this.isObjectiveMarkersEnabled = var1;
   }

   @Nonnull
   class="kw">public Set<String> getDisabledFluidTickers() {
      class="kw">return this.disabledFluidTickers;
   }

   class="kw">public void setDisabledFluidTickers(@Nonnull Set<String> var1) {
      this.disabledFluidTickers = var1;
   }

   class="kw">public IResourceStorageProvider getResourceStorageProvider() {
      class="kw">return this.resourceStorageProvider;
   }

   class="kw">public void setResourceStorageProvider(@Nonnull IResourceStorageProvider var1) {
      this.resourceStorageProvider = var1;
   }

   class="kw">public MapKeyMapCodec.TypeMap<Object> getPluginConfig() {
      class="kw">return this.pluginConfig;
   }

   class="kw">public void markChanged() {
      this.hasChanged.set(true);
   }

   class="kw">public boolean consumeHasChanged() {
      class="kw">return this.hasChanged.getAndSet(false);
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<WorldConfig> load(@Nonnull Path var0) {
      class="kw">return CompletableFuture.supplyAsync(() -> {
         WorldConfig var1 = RawJsonReader.readSyncWithBak(var0, CODEC, HytaleLogger.getLogger());
         class="kw">return var1 != null ? var1 : new WorldConfig();
      });
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<Void> save(@Nonnull Path var0, WorldConfig var1) {
      BsonDocument var2 = CODEC.encode(var1, ExtraInfo.THREAD_LOCAL.get());
      class="kw">return BsonUtil.writeDocument(var0, var2);
   }

   class="kw">public class="kw">static class ChunkConfig {
      class="kw">public class="kw">static class="kw">final BuilderCodec<WorldConfig.ChunkConfig> CODEC = BuilderCodec.builder(WorldConfig.ChunkConfig.class, WorldConfig.ChunkConfig::new)
         .appendInherited(
            new KeyedCodec<>("PregenerateRegion", Box2D.CODEC),
            (var0, var1) -> var0.pregenerateRegion = var1,
            var0 -> var0.pregenerateRegion,
            (var0, var1) -> var0.pregenerateRegion = var1.pregenerateRegion
         )
         .documentation("Sets the region that will be pregenerated for the world.\n\nIf set, the specified region will be pregenerated when the world starts.")
         .add()
         .<Box2D>appendInherited(
            new KeyedCodec<>("KeepLoadedRegion", Box2D.CODEC),
            (var0, var1) -> var0.keepLoadedRegion = var1,
            var0 -> var0.keepLoadedRegion,
            (var0, var1) -> var0.keepLoadedRegion = var1.keepLoadedRegion
         )
         .documentation("Sets a region of chunks that will never be unloaded.")
         .add()
         .afterDecode(var0 -> {
            if (var0.pregenerateRegion != null) {
               var0.pregenerateRegion.normalize();
            }

            if (var0.keepLoadedRegion != null) {
               var0.keepLoadedRegion.normalize();
            }
         })
         .build();
      class="kw">private class="kw">static class="kw">final Box2D DEFAULT_PREGENERATE_REGION = new Box2D(new Vector2d(-512.0, -512.0), new Vector2d(512.0, 512.0));
      @Nullable
      class="kw">private Box2D pregenerateRegion;
      @Nullable
      class="kw">private Box2D keepLoadedRegion;

      class="kw">public ChunkConfig() {
      }

      @Nullable
      class="kw">public Box2D getPregenerateRegion() {
         class="kw">return this.pregenerateRegion;
      }

      class="kw">public void setPregenerateRegion(@Nullable Box2D var1) {
         if (var1 != null) {
            var1.normalize();
         }

         this.pregenerateRegion = var1;
      }

      @Nullable
      class="kw">public Box2D getKeepLoadedRegion() {
         class="kw">return this.keepLoadedRegion;
      }

      class="kw">public void setKeepLoadedRegion(@Nullable Box2D var1) {
         if (var1 != null) {
            var1.normalize();
         }

         this.keepLoadedRegion = var1;
      }
   }
}