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

class="kw">import com.hypixel.hytale.assetstore.AssetLoadResult;
class="kw">import com.hypixel.hytale.assetstore.AssetMap;
class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.event.RegisterAssetStoreEvent;
class="kw">import com.hypixel.hytale.assetstore.event.RemoveAssetStoreEvent;
class="kw">import com.hypixel.hytale.assetstore.map.JsonAssetWithMap;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.codec.util.RawJsonReader;
class="kw">import com.hypixel.hytale.common.plugin.Mod;
class="kw">import com.hypixel.hytale.common.plugin.ModLoadOrderException;
class="kw">import com.hypixel.hytale.common.plugin.PluginIdentifier;
class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.common.semver.SemverRange;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.common.util.java.ManifestUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.logger.sentry.SkipSentryException;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.Options;
class="kw">import com.hypixel.hytale.server.core.ShutdownReason;
class="kw">import com.hypixel.hytale.server.core.asset.monitor.AssetMonitor;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.HomeOrSpawnPoint;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.RespawnController;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.WorldSpawnPoint;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.DroplistCommand;
class="kw">import com.hypixel.hytale.server.core.config.ModConfig;
class="kw">import com.hypixel.hytale.server.core.event.events.BootEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.AddPlayerToWorldEvent;
class="kw">import com.hypixel.hytale.server.core.permissions.HytalePermissions;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.plugin.PluginManager;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.IWorldGen;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.ValidatableWorldGen;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.WorldGenLoadException;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.IWorldMap;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.provider.IWorldMapProvider;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import java.awt.Color;
class="kw">import java.io.BufferedReader;
class="kw">import java.io.FileReader;
class="kw">import java.io.IOException;
class="kw">import java.nio.charset.StandardCharsets;
class="kw">import java.nio.file.DirectoryStream;
class="kw">import java.nio.file.FileSystem;
class="kw">import java.nio.file.FileSystems;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Comparator;
class="kw">import java.util.HashMap;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class AssetModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(AssetModule.class).build();
   class="kw">private class="kw">static AssetModule instance;
   @Nullable
   class="kw">private AssetMonitor assetMonitor;
   @Nonnull
   class="kw">private List<AssetPack> assetPacks = new CopyOnWriteArrayList<>();
   class="kw">private boolean hasLoaded = false;
   class="kw">private class="kw">final List<AssetStore<?, ?, ?>> pendingAssetStores = new CopyOnWriteArrayList<>();
   class="kw">private class="kw">final Set<String> missingPackWarnings = ConcurrentHashMap.newKeySet();

   class="kw">public class="kw">static AssetModule get() {
      class="kw">return instance;
   }

   class="kw">public AssetModule(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      if (Options.getOptionSet().has(Options.DISABLE_FILE_WATCHER)) {
         this.getLogger().at(Level.WARNING).log("Not running asset watcher because --disable-file-watcher was set");
      } else {
         try {
            this.assetMonitor = new AssetMonitor();
            this.getLogger().at(Level.INFO).log("Asset monitor enabled!");
         } catch (IOException var9) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var9)).log("Failed to create asset monitor!");
         }
      }

      for (Path var3 : Options.getOptionSet().valuesOf(Options.ASSET_DIRECTORY)) {
         this.loadAndRegisterPack(var3, false);
      }

      for (PluginManager.ClasspathAssetPack var14 : PluginManager.get().consumeClasspathAssetPacks()) {
         String var4 = new PluginIdentifier(var14.manifest()).toString();
         if (!this.registerPack(var4, var14.path(), var14.manifest(), AssetPack.PackSource.CLASSPATH)) {
            Message var5 = Message.translation("client.disconnection.shutdownReason.packDuplicate").param("pack", var4);
            HytaleServer.get().shutdownServer(ShutdownReason.MOD_ERROR.withMessage(var5));
            class="kw">return;
         }
      }

      this.loadPacksFromDirectory(PluginManager.MODS_PATH);

      for (Path var15 : Options.getOptionSet().valuesOf(Options.MODS_DIRECTORIES)) {
         this.loadPacksFromDirectory(var15);
      }

      if (this.assetPacks.isEmpty()) {
         Message var13 = Message.translation("client.disconnection.shutdownReason.missingAssets.failedToLoad");
         HytaleServer.get().shutdownServer(ShutdownReason.MISSING_ASSETS.withMessage(var13));
      } else {
         ArrayList var12 = new ArrayList<>();
         String var16 = ManifestUtil.getVersion();

         for (AssetPack var18 : this.assetPacks) {
            if (!var18.getName().equals("Hytale:Hytale")) {
               PluginManifest var6 = var18.getManifest();
               SemverRange var7 = var6.getServerVersion();
               PluginManifest.ServerVersionCheck var8 = PluginManifest.checkServerVersionCompatibility(var7, var16);
               if (var8 != PluginManifest.ServerVersionCheck.COMPATIBLE) {
                  var12.add(var18.getName());
                  class="kw">switch (var8) {
                     case MISSING:
                        this.getLogger()
                           .at(Level.WARNING)
                           .log(
                              "Plugin '%s' does not specify a target server version. You may encounter issues, please check for plugin updates. This will be a hard error in the future",
                              var18.getName()
                           );
                        break;
                     case PARSE_FAILED:
                        this.getLogger()
                           .at(Level.WARNING)
                           .log(
                              "Plugin '%s' targets server version range '%s' but the running server version '%s' could not be parsed.",
                              var18.getName(),
                              var7,
                              var16
                           );
                        break;
                     case INCOMPATIBLE:
                        this.getLogger()
                           .at(Level.WARNING)
                           .log(
                              "Plugin '%s' targets server version range '%s' which does not match the running server version '%s'. You may encounter issues, please check for plugin updates.",
                              var18.getName(),
                              var7,
                              var16
                           );
                        break;
                     case COMPATIBLE:
                        throw new IllegalStateException("unreachable");
                  }
               }
            }
         }

         if (!var12.isEmpty() && System.getProperty("hytale.allow_outdated_mods") == null) {
            this.getLogger()
               .at(Level.SEVERE)
               .log("One or more asset packs are targeting an older server version. It is recommended to update these plugins to ensure compatibility.");
            HytaleServer.get()
               .getEventBus()
               .registerGlobal(
                  AddPlayerToWorldEvent.class,
                  var1 -> {
                     PlayerRef var2 = var1.getHolder().getComponent(PlayerRef.getComponentType());
                     if (var2 != null && var2.hasPermission(HytalePermissions.MODS_OUTDATED_NOTIFY)) {
                        StringBuilder var3 = new StringBuilder();

                        for (String var5 : var12) {
                           var3.append("\n - ").append(var5);
                        }

                        var2.sendMessage(
                           Message.translation("server.assetModule.outOfDatePacks")
                              .param("count", var12.size())
                              .param("mods", var3.toString())
                              .color(Color.RED)
                        );
                     }
                  }
               );
         }

         this.getEventRegistry().register((short)-16, LoadAssetEvent.class, this::loadAllAssetPacks);
         this.getEventRegistry().register((short)-16, AssetPackRegisterEvent.class, var0 -> AssetRegistryLoader.loadAssets(null, var0.getAssetPack()));
         this.getEventRegistry().register(AssetPackUnregisterEvent.class, var0 -> {
            for (AssetStore var2 : AssetRegistry.getStoreMap().values()) {
               var2.removeAssetPack(var0.getAssetPack().getName());
            }
         });
         this.getEventRegistry().register(LoadAssetEvent.class, AssetModule::validateWorldGen);
         this.getEventRegistry().register(RegisterAssetStoreEvent.class, this::onNewStore);
         this.getEventRegistry().register(RemoveAssetStoreEvent.class, this::onRemoveStore);
         this.getEventRegistry().registerGlobal(BootEvent.class, var1 -> {
            StringBuilder var2 = new StringBuilder("Total Loaded Assets: ");
            AssetStore[] var3 = AssetRegistry.getStoreMap().values().toArray(AssetStore[]::new);
            Arrays.sort(var3, Comparator.comparingInt(var0 -> var0.getAssetMap().getAssetCount()));

            for (int var4 = var3.length - 1; var4 >= 0; var4--) {
               AssetStore var5 = var3[var4];
               String var6 = var5.getAssetClass().getSimpleName();
               int var7 = var5.getAssetMap().getAssetCount();
               var2.append(var6).append(": ").append(var7).append(", ");
            }

            var2.setLength(var2.length() - 2);
            this.getLogger().at(Level.INFO).log("%s", var2.toString());
         });
         RespawnController.CODEC.register("HomeOrSpawnPoint", HomeOrSpawnPoint.class, HomeOrSpawnPoint.CODEC);
         RespawnController.CODEC.register("WorldSpawnPoint", WorldSpawnPoint.class, WorldSpawnPoint.CODEC);
         this.getCommandRegistry().registerCommand(new DroplistCommand());
      }
   }

   @Override
   class="kw">protected void shutdown() {
      if (this.assetMonitor != null) {
         this.assetMonitor.shutdown();
         this.assetMonitor = null;
      }

      for (AssetPack var2 : this.assetPacks) {
         if (var2.getFileSystem() != null) {
            try {
               var2.getFileSystem().close();
            } catch (IOException var4) {
               ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(var4)).log("Failed to close asset pack filesystem: %s", var2.getName());
            }
         }
      }

      this.assetPacks.clear();
   }

   @Nonnull
   class="kw">public AssetPack getBaseAssetPack() {
      class="kw">return this.assetPacks.getFirst();
   }

   @Nonnull
   class="kw">public List<AssetPack> getAssetPacks() {
      class="kw">return this.assetPacks;
   }

   @Nullable
   class="kw">public AssetMonitor getAssetMonitor() {
      class="kw">return this.assetMonitor;
   }

   @Nullable
   class="kw">public AssetPack findAssetPackForPath(Path var1) {
      for (AssetPack var3 : this.assetPacks) {
         if (var3.contains(var1)) {
            class="kw">return var3;
         }
      }

      class="kw">return null;
   }

   class="kw">public boolean isWithinPackSubDir(@Nonnull Path var1, @Nonnull String var2) {
      for (AssetPack var4 : this.assetPacks) {
         Path var5 = var4.getRoot().resolve(var2);
         if (PathUtil.isChildOf(var5, var1)) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">public boolean isAssetPathImmutable(@Nonnull Path var1) {
      AssetPack var2 = this.findAssetPackForPath(var1);
      class="kw">return var2 != null && var2.isImmutable();
   }

   @Nullable
   class="kw">private PluginManifest loadPackManifest(Path var1) class="kw">throws IOException {
      String var2 = var1.getFileName().toString().toLowerCase(Locale.ROOT);
      if (!var2.endsWith(".zip") && !var2.endsWith(".jar")) {
         if (Files.isDirectory(var1)) {
            Path var17 = var1.resolve("manifest.json");
            if (Files.exists(var17)) {
               try (FileReader var18 = new FileReader(var17.toFile(), StandardCharsets.UTF_8)) {
                  char[] var19 = RawJsonReader.READ_BUFFER.get();
                  RawJsonReader var20 = new RawJsonReader(var18, var19);
                  ExtraInfo var21 = ExtraInfo.THREAD_LOCAL.get();
                  PluginManifest var22 = PluginManifest.CODEC.decodeJson(var20, var21);
                  var21.getValidationResults().logOrThrowValidatorExceptions(this.getLogger());
                  class="kw">return var22;
               }
            }
         }
      } else {
         try (FileSystem var3 = FileSystems.newFileSystem(var1, (ClassLoader)null)) {
            Path var4 = var3.getPath("manifest.json");
            if (Files.exists(var4)) {
               try (BufferedReader var5 = Files.newBufferedReader(var4, StandardCharsets.UTF_8)) {
                  char[] var6 = RawJsonReader.READ_BUFFER.get();
                  RawJsonReader var7 = new RawJsonReader(var5, var6);
                  ExtraInfo var8 = ExtraInfo.THREAD_LOCAL.get();
                  PluginManifest var9 = PluginManifest.CODEC.decodeJson(var7, var8);
                  var8.getValidationResults().logOrThrowValidatorExceptions(this.getLogger());
                  class="kw">return var9;
               }
            }
         }
      }

      class="kw">return null;
   }

   class="kw">private void loadPacksFromDirectory(Path var1) {
      if (Files.isDirectory(var1)) {
         this.getLogger().at(Level.INFO).log("Loading packs from directory: %s", var1);

         try (DirectoryStream var2 = Files.newDirectoryStream(var1)) {
            for (Path var4 : var2) {
               if (var4.getFileName() != null) {
                  this.loadAndRegisterPack(var4, true);
               }
            }
         } catch (IOException var7) {
            ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var7)).log("Failed to load mods from: %s", var1);
         }
      }
   }

   class="kw">private void loadAndRegisterPack(Path var1, boolean var2) {
      PluginManifest var3;
      try {
         var3 = this.loadPackManifest(var1);
         if (var3 == null) {
            this.getLogger().at(Level.WARNING).log("Skipping pack at %s: missing or invalid manifest.json", var1.getFileName());
            class="kw">return;
         }
      } catch (Exception var11) {
         ((HytaleLogger.Api)this.getLogger().at(Level.WARNING).withCause(new SkipSentryException(var11))).log("Failed to load manifest for pack at %s", var1);
         class="kw">return;
      }

      if (var1.getFileName().toString().toLowerCase(Locale.ROOT).endsWith(".jar") && !var3.includesAssetPack()) {
         this.getLogger().at(Level.FINE).log("Skipping jar without asset pack: %s", var1.getFileName());
      } else {
         PluginIdentifier var4 = new PluginIdentifier(var3);
         String var5 = var4.toString();
         AssetPack.PackSource var6 = var2 ? AssetPack.PackSource.MODS : AssetPack.PackSource.CLI;
         HytaleServerConfig var7 = HytaleServer.get().getConfig();
         ModConfig var8 = var7.getModConfig().get(var4);
         boolean var9;
         if (var8 != null && var8.getEnabled() != null) {
            var9 = var8.getEnabled();
         } else {
            var9 = !var3.isDisabledByDefault() && (!var2 || var7.getDefaultModsEnabled());
         }

         if (var9) {
            if (!this.registerPack(var5, var1, var3, var6)) {
               Message var10 = Message.translation("client.disconnection.shutdownReason.packDuplicate").param("pack", var5);
               HytaleServer.get().shutdownServer(ShutdownReason.MOD_ERROR.withMessage(var10));
               class="kw">return;
            }

            this.getLogger().at(Level.INFO).log("Loaded pack: %s from %s", var5, var1.getFileName());
         } else {
            this.getLogger().at(Level.INFO).log("Skipped disabled pack: %s", var5);
         }
      }
   }

   class="kw">public boolean registerPack(@Nonnull String var1, @Nonnull Path var2, @Nonnull PluginManifest var3, @Nonnull AssetPack.PackSource var4) {
      AssetPack var5 = this.getAssetPack(var1);
      if (var5 != null) {
         if (var5.getSource().overrides(var4)) {
            this.getLogger().at(Level.WARNING).log("Asset pack '%s' already registered (%s), skipping %s: %s", var1, var5.getSource(), var4, var2);
            class="kw">return true;
         }

         if (!var4.overrides(var5.getSource())) {
            this.getLogger()
               .at(Level.SEVERE)
               .log("Duplicate asset pack '%s' at %s (already loaded from %s). Remove the duplicate.", var1, var2, var5.getPackLocation());
            class="kw">return false;
         }

         this.getLogger().at(Level.WARNING).log("Asset pack '%s' overriding %s with %s: %s", var1, var5.getSource(), var4, var2);
         this.unregisterPack(var1);
      }

      Path var6 = var2.toAbsolutePath().normalize();
      Path var7 = var6;
      FileSystem var8 = null;
      boolean var9 = false;
      String var10 = var6.getFileName().toString().toLowerCase(Locale.ROOT);
      if (!var10.endsWith(".zip") && !var10.endsWith(".jar")) {
         var9 = Files.isRegularFile(var6.resolve("CommonAssetsIndex.hashes"));
      } else {
         try {
            var8 = FileSystems.newFileSystem(var6, (ClassLoader)null);
            var6 = var8.getPath("").toAbsolutePath().normalize();
            var9 = true;
         } catch (IOException var16) {
            throw SneakyThrow.sneakyThrow(var16);
         }
      }

      AssetPack var11 = new AssetPack(var7, var1, var6, var8, var9, var3, var4);
      this.assetPacks.add(var11);
      AssetRegistry.ASSET_LOCK.writeLock().lock();

      try {
         if (!this.hasLoaded) {
            class="kw">return true;
         }

         HytaleServer.get().getEventBus().<Void, AssetPackRegisterEvent>dispatchFor(AssetPackRegisterEvent.class).dispatch(new AssetPackRegisterEvent(var11));
      } class="kw">finally {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }

      class="kw">return true;
   }

   class="kw">public void unregisterPack(@Nonnull String var1) {
      AssetPack var2 = this.getAssetPack(var1);
      if (var2 == null) {
         this.getLogger().at(Level.WARNING).log("Tried to unregister non-existent asset pack: %s", var1);
      } else {
         this.assetPacks.remove(var2);
         if (var2.getFileSystem() != null) {
            try {
               var2.getFileSystem().close();
            } catch (IOException var8) {
               throw SneakyThrow.sneakyThrow(var8);
            }
         }

         AssetRegistry.ASSET_LOCK.writeLock().lock();

         try {
            HytaleServer.get()
               .getEventBus()
               .<Void, AssetPackUnregisterEvent>dispatchFor(AssetPackUnregisterEvent.class)
               .dispatch(new AssetPackUnregisterEvent(var2));
         } class="kw">finally {
            AssetRegistry.ASSET_LOCK.writeLock().unlock();
         }
      }
   }

   class="kw">private void loadAllAssetPacks(LoadAssetEvent var1) {
      if (this.hasLoaded) {
         throw new IllegalStateException("LoadAssetEvent has already been dispatched");
      }

      AssetRegistry.ASSET_LOCK.writeLock().lock();

      try {
         this.hasLoaded = true;
         AssetRegistryLoader.preLoadAssets(var1);
         HashMap var2 = new HashMap<>();

         for (AssetPack var4 : this.assetPacks) {
            var2.put(PluginIdentifier.fromString(var4.getName()), var4);
         }

         List var11 = List.of(HytaleServer.get().getConfig().getModLoadOrder());

         try {
            this.assetPacks = new CopyOnWriteArrayList<>(Mod.calculateLoadOrder(var2, (var0, var1x) -> PluginManager.get().hasPlugin(var0, var1x), var11));
         } catch (ModLoadOrderException var9) {
            throw new IllegalStateException("Failed to calculate asset pack load order", var9);
         }

         for (AssetPack var5 : this.assetPacks) {
            AssetRegistryLoader.loadAssets(var1, var5);
         }
      } class="kw">finally {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }
   }

   class="kw">public boolean validatePackExistsOnDisk(@Nonnull AssetPack var1) {
      if (!var1.existsOnDisk()) {
         if (this.missingPackWarnings.add(var1.getName())) {
            this.getLogger().at(Level.WARNING).log("Asset pack '%s' no longer exists on disk", var1.getName());
         }

         class="kw">return false;
      } else {
         this.missingPackWarnings.remove(var1.getName());
         class="kw">return true;
      }
   }

   class="kw">public AssetPack getAssetPack(@Nonnull String var1) {
      for (AssetPack var3 : this.assetPacks) {
         if (var1.equals(var3.getName())) {
            class="kw">return var3;
         }
      }

      class="kw">return null;
   }

   class="kw">private void onRemoveStore(@Nonnull RemoveAssetStoreEvent var1) {
      AssetStore var2 = (AssetStore<?, ? class="kw">extends JsonAssetWithMap<?, ? class="kw">extends AssetMap<?, ?>>, ? class="kw">extends AssetMap<?, ? class="kw">extends JsonAssetWithMap<?, ?>>>)var1.getAssetStore();
      String var3 = var2.getPath();
      if (var3 != null) {
         for (AssetPack var5 : this.assetPacks) {
            if (!var5.isImmutable()) {
               Path var6 = var5.getRoot().resolve("Server").resolve(var3);
               if (Files.isDirectory(var6)) {
                  var2.removeFileMonitor(var6);
               }
            }
         }
      }
   }

   class="kw">private void onNewStore(@Nonnull RegisterAssetStoreEvent var1) {
      if (AssetRegistry.HAS_INIT) {
         this.pendingAssetStores.add(var1.getAssetStore());
      }
   }

   class="kw">public void initPendingStores() {
      for (int var1 = 0; var1 < this.pendingAssetStores.size(); var1++) {
         this.initStore(this.pendingAssetStores.get(var1));
      }

      this.pendingAssetStores.clear();
   }

   class="kw">private void initStore(@Nonnull AssetStore<?, ?, ?> var1) {
      AssetRegistry.ASSET_LOCK.writeLock().lock();

      try {
         List var2 = var1.getPreAddedAssets();
         if (var2 != null && !var2.isEmpty()) {
            AssetLoadResult var3 = var1.loadAssets("Hytale:Hytale", var2);
            if (var3.hasFailed()) {
               throw new RuntimeException("Failed to load asset store: " + var1.getAssetClass());
            }
         }

         for (AssetPack var4 : this.assetPacks) {
            Path var5 = var4.getRoot().resolve("Server");
            String var6 = var1.getPath();
            if (var6 != null) {
               Path var7 = var5.resolve(var6);
               if (Files.isDirectory(var7)) {
                  AssetLoadResult var8 = (AssetLoadResult<?, ? class="kw">extends JsonAssetWithMap<?, ? class="kw">extends AssetMap<?, ?>>>)var1.loadAssetsFromDirectory(
                     var4.getName(), var7
                  );
                  if (var8.hasFailed()) {
                     throw new RuntimeException("Failed to load asset store: " + var1.getAssetClass());
                  }
               } else {
                  this.getLogger().at(Level.SEVERE).log("Path for %s isn't a directory or doesn't exist: %s", var1.getAssetClass().getSimpleName(), var7);
               }
            }

            var1.validateCodecDefaults();
            if (var6 != null) {
               Path var15 = var5.resolve(var6);
               if (Files.isDirectory(var15)) {
                  var1.addFileMonitor(var4.getName(), var15);
               }
            }
         }
      } catch (IOException var12) {
         throw SneakyThrow.sneakyThrow(var12);
      } class="kw">finally {
         AssetRegistry.ASSET_LOCK.writeLock().unlock();
      }
   }

   class="kw">private class="kw">static void validateWorldGen(@Nonnull LoadAssetEvent var0) {
      if (Options.getOptionSet().has(Options.VALIDATE_WORLD_GEN)) {
         long var1 = System.nanoTime();

         try {
            IWorldGenProvider var3 = IWorldGenProvider.CODEC.getDefault();
            IWorldGen var4 = var3.getGenerator();
            var4.getDefaultSpawnProvider(0);
            if (var4 class="kw">instanceof ValidatableWorldGen) {
               boolean var5 = ((ValidatableWorldGen)var4).validate();
               if (!var5) {
                  var0.failed(true, "failed to validate world gen");
               }
            }

            if (var4 class="kw">instanceof IWorldMapProvider var9) {
               IWorldMap var6 = var9.getGenerator(null);
               var6.getWorldMapSettings();
            }
         } catch (WorldGenLoadException var7) {
            ((HytaleLogger.Api)HytaleLogger.getLogger().at(Level.SEVERE).withCause(var7)).log("Failed to load class="kw">default world gen!");
            HytaleLogger.getLogger().at(Level.SEVERE).log("\n%s", var7.getTraceMessage("\n"));
            var0.failed(true, "failed to validate world gen: " + var7.getTraceMessage(" -> "));
         } catch (Throwable var8) {
            ((HytaleLogger.Api)HytaleLogger.getLogger().at(Level.SEVERE).withCause(var8)).log("Failed to load class="kw">default world gen!");
            var0.failed(true, "failed to validate world gen");
         }

         HytaleLogger.getLogger()
            .at(Level.INFO)
            .log(
               "Validate world gen phase completed! Boot time %s, Took %s",
               FormatUtil.nanosToString(System.nanoTime() - var0.getBootStart()),
               FormatUtil.nanosToString(System.nanoTime() - var1)
            );
      }
   }
}