class="kw">package com.hypixel.hytale.builtin.instances;

class="kw">import com.hypixel.hytale.assetstore.AssetPack;
class="kw">import com.hypixel.hytale.builtin.blockphysics.WorldValidationUtil;
class="kw">import com.hypixel.hytale.builtin.instances.blocks.ConfigurableInstanceBlock;
class="kw">import com.hypixel.hytale.builtin.instances.blocks.InstanceBlock;
class="kw">import com.hypixel.hytale.builtin.instances.command.InstancesCommand;
class="kw">import com.hypixel.hytale.builtin.instances.config.ExitInstance;
class="kw">import com.hypixel.hytale.builtin.instances.config.InstanceDiscoveryConfig;
class="kw">import com.hypixel.hytale.builtin.instances.config.InstanceEntityConfig;
class="kw">import com.hypixel.hytale.builtin.instances.config.InstanceWorldConfig;
class="kw">import com.hypixel.hytale.builtin.instances.config.WorldReturnPoint;
class="kw">import com.hypixel.hytale.builtin.instances.event.DiscoverInstanceEvent;
class="kw">import com.hypixel.hytale.builtin.instances.hud.InstanceRemovalHudSystem;
class="kw">import com.hypixel.hytale.builtin.instances.interactions.ExitInstanceInteraction;
class="kw">import com.hypixel.hytale.builtin.instances.interactions.TeleportConfigInstanceInteraction;
class="kw">import com.hypixel.hytale.builtin.instances.interactions.TeleportInstanceInteraction;
class="kw">import com.hypixel.hytale.builtin.instances.page.ConfigureInstanceBlockPage;
class="kw">import com.hypixel.hytale.builtin.instances.removal.IdleTimeoutCondition;
class="kw">import com.hypixel.hytale.builtin.instances.removal.InstanceDataResource;
class="kw">import com.hypixel.hytale.builtin.instances.removal.RemovalCondition;
class="kw">import com.hypixel.hytale.builtin.instances.removal.RemovalSystem;
class="kw">import com.hypixel.hytale.builtin.instances.removal.TimeoutCondition;
class="kw">import com.hypixel.hytale.builtin.instances.removal.WorldEmptyCondition;
class="kw">import com.hypixel.hytale.builtin.teleport.components.TeleportHistory;
class="kw">import com.hypixel.hytale.codec.schema.config.ObjectSchema;
class="kw">import com.hypixel.hytale.codec.schema.config.Schema;
class="kw">import com.hypixel.hytale.codec.schema.config.StringSchema;
class="kw">import com.hypixel.hytale.common.util.FormatUtil;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentRegistryProxy;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.event.EventRegistry;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
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.asset.AssetModule;
class="kw">import com.hypixel.hytale.server.core.asset.LoadAssetEvent;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.respawn.RespawnController;
class="kw">import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.data.PlayerConfigData;
class="kw">import com.hypixel.hytale.server.core.event.events.player.AddPlayerToWorldEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.DrainPlayerFromWorldEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerConnectEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerReadyEvent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.OpenCustomUIInteraction;
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.schema.SchemaGenerator;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.SoundUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.ValidationOption;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.WorldConfig;
class="kw">import com.hypixel.hytale.server.core.universe.world.spawn.ISpawnProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.EmptyChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.IChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.MigrationChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.resources.EmptyResourceStorageProvider;
class="kw">import com.hypixel.hytale.server.core.util.EventTitleUtil;
class="kw">import com.hypixel.hytale.server.core.util.io.FileUtil;
class="kw">import com.hypixel.hytale.sneakythrow.SneakyThrow;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.FileVisitResult;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.SimpleFileVisitor;
class="kw">import java.nio.file.attribute.BasicFileAttributes;
class="kw">import java.util.EnumSet;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
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.ConcurrentHashMap;
class="kw">import java.util.logging.Level;
class="kw">import java.util.stream.Stream;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class InstancesPlugin class="kw">extends JavaPlugin {
   class="kw">private class="kw">static InstancesPlugin instance;
   @Nonnull
   class="kw">public class="kw">static class="kw">final String INSTANCE_PREFIX = "instance-";
   @Nonnull
   class="kw">public class="kw">static class="kw">final String CONFIG_FILENAME = "instance.bson";
   class="kw">private ResourceType<ChunkStore, InstanceDataResource> instanceDataResourceType;
   class="kw">private ComponentType<EntityStore, InstanceEntityConfig> instanceEntityConfigComponentType;
   class="kw">private class="kw">final Map<String, CompletableFuture<World>> pendingSpawns = new ConcurrentHashMap<>();
   class="kw">private ComponentType<ChunkStore, InstanceBlock> instanceBlockComponentType;
   class="kw">private ComponentType<ChunkStore, ConfigurableInstanceBlock> configurableInstanceBlockComponentType;

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

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

   @Override
   class="kw">protected void setup() {
      EventRegistry var1 = this.getEventRegistry();
      ComponentRegistryProxy var2 = this.getChunkStoreRegistry();
      this.getCommandRegistry().registerCommand(new InstancesCommand());
      var1.register((short)64, LoadAssetEvent.class, this::validateInstanceAssets);
      SchemaGenerator.registerAssetSchema("InstanceConfig.json", var0 -> {
         ObjectSchema var1 = WorldConfig.CODEC.toSchema(var0);
         Map var2 = var1.getProperties();
         var2.put("UUID", Schema.anyOf(new StringSchema(), new ObjectSchema()));
         var1.setTitle("Instance Configuration");
         var1.setId("InstanceConfig.json");
         Schema.HytaleMetadata var3 = var1.getHytale();
         var3.setPath("Instances");
         var3.setExtension("instance.bson");
         var3.setUiEditorIgnore(Boolean.TRUE);
         class="kw">return var1;
      }, List.of("Instances/**/instance.bson"), ".bson");
      var1.registerGlobal(AddPlayerToWorldEvent.class, InstancesPlugin::onPlayerAddToWorld);
      var1.registerGlobal(DrainPlayerFromWorldEvent.class, InstancesPlugin::onPlayerDrainFromWorld);
      var1.register(PlayerConnectEvent.class, InstancesPlugin::onPlayerConnect);
      var1.registerGlobal(PlayerReadyEvent.class, InstancesPlugin::onPlayerReady);
      this.instanceBlockComponentType = var2.registerComponent(InstanceBlock.class, "Instance", InstanceBlock.CODEC);
      var2.registerSystem(new InstanceBlock.OnRemove());
      this.configurableInstanceBlockComponentType = var2.registerComponent(ConfigurableInstanceBlock.class, "InstanceConfig", ConfigurableInstanceBlock.CODEC);
      var2.registerSystem(new ConfigurableInstanceBlock.OnRemove());
      this.instanceDataResourceType = var2.registerResource(InstanceDataResource.class, "InstanceData", InstanceDataResource.CODEC);
      var2.registerSystem(new RemovalSystem());
      this.instanceEntityConfigComponentType = this.getEntityStoreRegistry()
         .registerComponent(InstanceEntityConfig.class, "Instance", InstanceEntityConfig.CODEC);
      this.getEntityStoreRegistry().registerSystem(new InstanceRemovalHudSystem());
      this.getCodecRegistry(RemovalCondition.CODEC)
         .register("WorldEmpty", WorldEmptyCondition.class, WorldEmptyCondition.CODEC)
         .register("IdleTimeout", IdleTimeoutCondition.class, IdleTimeoutCondition.CODEC)
         .register("Timeout", TimeoutCondition.class, TimeoutCondition.CODEC);
      this.getCodecRegistry(Interaction.CODEC)
         .register("TeleportInstance", TeleportInstanceInteraction.class, TeleportInstanceInteraction.CODEC)
         .register("TeleportConfigInstance", TeleportConfigInstanceInteraction.class, TeleportConfigInstanceInteraction.CODEC)
         .register("ExitInstance", ExitInstanceInteraction.class, ExitInstanceInteraction.CODEC);
      this.getCodecRegistry(RespawnController.CODEC).register("ExitInstance", ExitInstance.class, ExitInstance.CODEC);
      OpenCustomUIInteraction.registerBlockEntityCustomPage(
         this, ConfigureInstanceBlockPage.class, "ConfigInstanceBlock", ConfigureInstanceBlockPage::new, () -> {
            Holder var0 = ChunkStore.REGISTRY.newHolder();
            var0.ensureComponent(ConfigurableInstanceBlock.getComponentType());
            class="kw">return var0;
         }
      );
      this.getCodecRegistry(WorldConfig.PLUGIN_CODEC).register(InstanceWorldConfig.class, "Instance", InstanceWorldConfig.CODEC);
   }

   @Nonnull
   class="kw">public CompletableFuture<World> spawnInstance(@Nonnull String var1, @Nonnull World var2, @Nonnull Transform var3) {
      class="kw">return this.spawnInstance(var1, null, var2, var3);
   }

   @Nonnull
   class="kw">public CompletableFuture<World> spawnInstance(@Nonnull String var1, @Nullable String var2, @Nonnull World var3, @Nonnull Transform var4) {
      Universe var5 = Universe.get();
      if (var2 != null) {
         World var6 = var5.getWorld(var2);
         if (var6 != null) {
            class="kw">return CompletableFuture.completedFuture(var6);
         }
      }

      Path var7 = getInstanceAssetPath(var1);
      class="kw">return WorldConfig.load(var7.resolve("instance.bson")).thenComposeAsync(var7x -> {
         UUID var8 = UUID.randomUUID();
         var7x.setUuid(var8);
         if (var7x.getDisplayName() == null) {
            var7x.setDisplayName(WorldConfig.formatDisplayName(var1));
         }

         InstanceWorldConfig var9 = InstanceWorldConfig.ensureAndGet(var7x);
         var9.setInstanceName(var1);
         var9.setReturnPoint(makeWorldReturnPoint(var3, var4, var9.shouldPreventReconnection()));
         var7x.markChanged();
         String var10 = var2;
         if (var10 == null) {
            var10 = var9.getInstanceKey();
         }

         if (var10 == null) {
            var10 = "instance-" + safeName(var1) + "-" + var8;
         }

         World var11 = var5.getWorld(var10);
         if (var11 != null) {
            class="kw">return CompletableFuture.completedFuture(var11);
         }

         if (var9.shouldRespawnWhenTargeted() && var9.getInstanceKey() == null) {
            this.getLogger().at(Level.WARNING).log("Instance '%s' sets RespawnWhenTargeted without an InstanceKey, returns cannot find its copy", var1);
         }

         String var12 = var10;
         class="kw">return this.pendingSpawns.computeIfAbsent(var12, var4x -> {
            CompletableFuture var5 = this.copyAndLoadInstance(var1, var7, var4x, var7x);
            var5.whenComplete((var2x, var3x) -> this.pendingSpawns.remove(var4x));
            class="kw">return var5;
         });
      });
   }

   @Nonnull
   class="kw">private CompletableFuture<World> copyAndLoadInstance(@Nonnull String var1, @Nonnull Path var2, @Nonnull String var3, @Nonnull WorldConfig var4) {
      Universe var5 = Universe.get();
      Path var6 = var5.validateWorldPath(var3);
      class="kw">return CompletableFuture.supplyAsync(
            SneakyThrow.sneakySupplier(
               () -> {
                  long var6 = System.nanoTime();
                  this.getLogger().at(Level.INFO).log("Copying instance files for %s to world %s", var1, var3);

                  try (Stream var8 = Files.walk(var2, FileUtil.DEFAULT_WALK_TREE_OPTIONS_ARRAY)) {
                     var8.forEach(SneakyThrow.sneakyConsumer(var2x -> {
                        Path var3 = var2.relativize(var2x);
                        Path var4 = var6.resolve(var3.toString());
                        if (Files.isDirectory(var2x)) {
                           Files.createDirectories(var4);
                        } else {
                           if (Files.isRegularFile(var2x)) {
                              Files.copy(var2x, var4);
                           }
                        }
                     }));
                  }

                  this.getLogger()
                     .at(Level.INFO)
                     .log("Completed instance files for %s to world %s in %s", var1, var3, FormatUtil.nanosToString(System.nanoTime() - var6));
                  class="kw">return var4;
               }
            )
         )
         .thenCompose(var3x -> var5.makeWorld(var3, var6, var3x));
   }

   class="kw">public class="kw">static void teleportPlayerToLoadingInstance(
      @Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1, @Nonnull CompletableFuture<World> var2, @Nullable Transform var3
   ) {
      teleportPlayerToLoadingInstance(var0, var1, var2, var3, null);
   }

   class="kw">public class="kw">static void teleportPlayerToLoadingInstance(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull ComponentAccessor<EntityStore> var1,
      @Nonnull CompletableFuture<World> var2,
      @Nullable Transform var3,
      @Nullable Transform var4
   ) {
      World var5 = var1.getExternalData().getWorld();
      TransformComponent var6 = var1.getComponent(var0, TransformComponent.getComponentType());
      assert var6 != null;
      Transform var7 = new Transform(var6.getTransform());
      InstanceEntityConfig var8 = var1.getComponent(var0, InstanceEntityConfig.getComponentType());
      if (var8 == null) {
         var8 = var1.addComponent(var0, InstanceEntityConfig.getComponentType());
      }

      if (var3 != null) {
         var8.setReturnPointOverride(makeWorldReturnPoint(var5, var3, false));
      } else {
         var8.setReturnPointOverride(null);
      }

      PlayerRef var9 = var1.getComponent(var0, PlayerRef.getComponentType());
      assert var9 != null;
      UUIDComponent var10 = var1.getComponent(var0, UUIDComponent.getComponentType());
      assert var10 != null;
      UUID var11 = var10.getUuid();
      HeadRotation var12 = var1.getComponent(var0, HeadRotation.getComponentType());
      if (var12 != null) {
         var1.ensureAndGetComponent(var0, TeleportHistory.getComponentType())
            .append(var5, new Vector3d(var7.getPosition()), var12.getRotation().clone(), "Instance");
      }

      InstanceEntityConfig var13 = var8;
      Universe.transferPlayerAsync(var9, var5, var2, var2x -> {
         if (var4 != null) {
            class="kw">return var4;
         }

         ISpawnProvider var3 = var2x.getWorldConfig().getSpawnProvider();
         class="kw">return var3 != null ? var3.getSpawnPoint(var2x, var11) : null;
      }).whenComplete((var4x, var5x) -> {
         if (var5x != null) {
            ((HytaleLogger.Api)get().getLogger().at(Level.SEVERE).withCause(var5x)).log("Failed to send %s to instance world", var9.getUsername());
            var13.setReturnPointOverride(null);
         }

         if (var4x == null) {
            if (var5.isAlive()) {
               var5.addPlayer(var9, var7, Boolean.TRUE, Boolean.FALSE);
            } else {
               World var6 = Universe.get().getDefaultWorld();
               if (var6 != null) {
                  var6.addPlayer(var9, null, Boolean.TRUE, Boolean.FALSE);
               } else {
                  get().getLogger().at(Level.SEVERE).log("No fallback world for %s, disconnecting", var9.getUsername());
                  var9.getPacketHandler().disconnect(Message.translation("server.general.disconnect.teleportNoWorld"));
               }
            }
         }
      });
   }

   class="kw">public class="kw">static void teleportPlayerToInstance(
      @Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1, @Nonnull World var2, @Nullable Transform var3
   ) {
      World var4 = var1.getExternalData().getWorld();
      WorldConfig var5 = var4.getWorldConfig();
      if (var3 != null) {
         InstanceEntityConfig var6 = var1.ensureAndGetComponent(var0, InstanceEntityConfig.getComponentType());
         var6.setReturnPointOverride(makeWorldReturnPoint(var4, var3, false));
      }

      UUIDComponent var14 = var1.getComponent(var0, UUIDComponent.getComponentType());
      assert var14 != null;
      UUID var7 = var14.getUuid();
      WorldConfig var8 = var2.getWorldConfig();
      ISpawnProvider var9 = var8.getSpawnProvider();
      if (var9 == null) {
         throw new IllegalStateException("Spawn provider cannot be null when teleporting player to instance!");
      }

      TransformComponent var10 = var1.getComponent(var0, TransformComponent.getComponentType());
      HeadRotation var11 = var1.getComponent(var0, HeadRotation.getComponentType());
      if (var10 != null && var11 != null) {
         var1.ensureAndGetComponent(var0, TeleportHistory.getComponentType())
            .append(var4, new Vector3d(var10.getPosition()), var11.getRotation().clone(), "Instance '" + var2.getName() + "'");
      }

      Transform var12 = var9.getSpawnPoint(var2, var7);
      Teleport var13 = Teleport.createForPlayer(var2, var12);
      var1.addComponent(var0, Teleport.getComponentType(), var13);
   }

   class="kw">public class="kw">static CompletableFuture<Void> exitInstance(@Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1) {
      World var2 = var1.getExternalData().getWorld();
      InstanceEntityConfig var3 = var1.getComponent(var0, InstanceEntityConfig.getComponentType());
      WorldReturnPoint var4 = var3 != null ? var3.getReturnPoint() : null;
      if (var4 == null) {
         WorldConfig var5 = var2.getWorldConfig();
         InstanceWorldConfig var6 = InstanceWorldConfig.get(var5);
         var4 = var6 != null ? var6.getReturnPoint() : null;
         if (var4 == null) {
            throw new IllegalArgumentException("Player is not in an instance");
         }
      }

      Universe var12 = Universe.get();
      World var13 = var12.getWorld(var4.getWorld());
      if (var13 == null && var4.getInstanceName() != null && var4.getInstanceKey() != null) {
         var13 = var12.getWorld(var4.getInstanceKey());
         if (var13 == null) {
            class="kw">return returnToRespawnedInstance(var0, var1, var3, var4);
         }
      }

      while (var13 == null && var3 != null) {
         WorldReturnPoint var7 = var3.popReturnPoint();
         if (var7 == null) {
            break;
         }

         var4 = var7;
         var13 = var12.getWorld(var4.getWorld());
      }

      Transform var14 = var4.getReturnPoint();
      if (var13 == null) {
         var13 = var12.getDefaultWorld();
         UUIDComponent var8 = var1.getComponent(var0, UUIDComponent.getComponentType());
         ISpawnProvider var9 = var13 != null ? var13.getWorldConfig().getSpawnProvider() : null;
         var14 = var9 != null && var8 != null ? var9.getSpawnPoint(var13, var8.getUuid()) : null;
         if (var13 == null || var14 == null) {
            throw new IllegalArgumentException("Missing class="kw">return world");
         }

         get().getLogger().at(Level.WARNING).log("Return world for instance '%s' is gone, sending the player to the class="kw">default world spawn", var2.getName());
      }

      TransformComponent var15 = var1.getComponent(var0, TransformComponent.getComponentType());
      HeadRotation var16 = var1.getComponent(var0, HeadRotation.getComponentType());
      if (var15 != null && var16 != null) {
         var1.ensureAndGetComponent(var0, TeleportHistory.getComponentType())
            .append(var2, new Vector3d(var15.getPosition()), var16.getRotation().clone(), "Instance '" + var2.getName() + "'");
      }

      Teleport var10 = Teleport.createForPlayer(var13, var14);
      CompletableFuture var11 = new CompletableFuture<>();
      var10.setOnComplete(var11);
      var1.addComponent(var0, Teleport.getComponentType(), var10);
      class="kw">return var11;
   }

   @Nonnull
   class="kw">private class="kw">static WorldReturnPoint makeWorldReturnPoint(@Nonnull World var0, @Nonnull Transform var1, boolean var2) {
      InstanceWorldConfig var3 = InstanceWorldConfig.get(var0.getWorldConfig());
      boolean var4 = var3 != null && var3.shouldRespawnWhenTargeted() && var3.getInstanceKey() != null;
      class="kw">return new WorldReturnPoint(var0.getWorldConfig().getUuid(), var1, var2, var4 ? var3.getInstanceName() : null, var4 ? var3.getInstanceKey() : null);
   }

   @Nonnull
   class="kw">private class="kw">static CompletableFuture<Void> returnToRespawnedInstance(
      @Nonnull Ref<EntityStore> var0, @Nonnull ComponentAccessor<EntityStore> var1, @Nullable InstanceEntityConfig var2, @Nonnull WorldReturnPoint var3
   ) {
      String var4 = var3.getInstanceName();
      String var5 = var3.getInstanceKey();
      assert var4 != null && var5 != null;
      Universe var6 = Universe.get();
      World var7 = null;
      Transform var8 = null;
      WorldReturnPoint var9;
      if (var2 != null) {
         while ((var9 = var2.popReturnPoint()) != null) {
            World var10 = var6.getWorld(var9.getWorld());
            if (var10 != null) {
               var7 = var10;
               var8 = var9.getReturnPoint();
               break;
            }
         }
      }

      if (var7 == null || var8 == null) {
         var7 = var6.getDefaultWorld();
         UUIDComponent var11 = var1.getComponent(var0, UUIDComponent.getComponentType());
         ISpawnProvider var13 = var7 != null ? var7.getWorldConfig().getSpawnProvider() : null;
         var8 = var13 != null && var11 != null ? var13.getSpawnPoint(var7, var11.getUuid()) : null;
         if (var7 == null || var8 == null) {
            throw new IllegalArgumentException("Missing class="kw">return world");
         }
      }

      CompletableFuture var12 = get().spawnInstance(var4, var5, var7, var8);
      teleportPlayerToLoadingInstance(var0, var1, var12, null, var3.getReturnPoint());
      class="kw">return var12.thenAccept(var0x -> {});
   }

   class="kw">public class="kw">static void safeRemoveInstance(@Nonnull String var0) {
      safeRemoveInstance(Universe.get().getWorld(var0));
   }

   class="kw">public class="kw">static void safeRemoveInstance(@Nonnull UUID var0) {
      safeRemoveInstance(Universe.get().getWorld(var0));
   }

   class="kw">public class="kw">static void safeRemoveInstance(@Nullable World var0) {
      if (var0 != null) {
         Store var1 = var0.getChunkStore().getStore();
         var1.getResource(InstanceDataResource.getResourceType()).setHadPlayer(true);
         WorldConfig var2 = var0.getWorldConfig();
         InstanceWorldConfig var3 = InstanceWorldConfig.get(var2);
         if (var3 != null) {
            var3.setRemovalConditions(WorldEmptyCondition.REMOVE_WHEN_EMPTY);
         }

         var2.markChanged();
      }
   }

   @Nonnull
   class="kw">public class="kw">static Path getInstanceAssetPath(@Nonnull String var0) {
      List var1 = AssetModule.get().getAssetPacks();

      for (int var2 = var1.size() - 1; var2 >= 0; var2--) {
         Path var3 = var1.get(var2).getRoot().resolve("Server").resolve("Instances");
         Path var4 = PathUtil.resolvePathWithinDir(var3, var0);
         if (var4 == null) {
            throw new IllegalArgumentException("Invalid instance name");
         }

         if (Files.exists(var4)) {
            class="kw">return var4;
         }
      }

      Path var5 = AssetModule.get().getBaseAssetPack().getRoot().resolve("Server").resolve("Instances");
      Path var6 = PathUtil.resolvePathWithinDir(var5, var0);
      if (var6 == null) {
         throw new IllegalArgumentException("Invalid instance name");
      } else {
         class="kw">return var6;
      }
   }

   class="kw">public class="kw">static boolean doesInstanceAssetExist(@Nonnull String var0) {
      class="kw">return Files.exists(getInstanceAssetPath(var0).resolve("instance.bson"));
   }

   @Nonnull
   class="kw">public class="kw">static CompletableFuture<World> loadInstanceAssetForEdit(@Nonnull String var0) {
      Path var1 = getInstanceAssetPath(var0);
      Universe var2 = Universe.get();
      class="kw">return WorldConfig.load(var1.resolve("instance.bson")).thenCompose(var3 -> {
         var3.setUuid(UUID.randomUUID());
         var3.setSavingPlayers(false);
         var3.setIsAllNPCFrozen(true);
         var3.setTicking(false);
         var3.setGameMode(GameMode.Creative);
         var3.setDeleteOnRemove(false);
         InstanceWorldConfig.ensureAndGet(var3).setRemovalConditions(RemovalCondition.EMPTY);
         var3.markChanged();
         String var4 = "instance-edit-" + safeName(var0);
         class="kw">return var2.makeWorld(var4, var1, var3);
      });
   }

   @Nonnull
   class="kw">public List<String> getInstanceAssets() {
      class="kw">final List var1 = new ObjectArrayList();

      for (AssetPack var3 : AssetModule.get().getAssetPacks()) {
         class="kw">final Path var4 = var3.getRoot().resolve("Server").resolve("Instances");
         if (Files.isDirectory(var4)) {
            try {
               Files.walkFileTree(var4, FileUtil.DEFAULT_WALK_TREE_OPTIONS_SET, Integer.MAX_VALUE, new SimpleFileVisitor<Path>() {
                  @Nonnull
                  class="kw">public FileVisitResult preVisitDirectory(@Nonnull Path var1x, @Nonnull BasicFileAttributes var2) {
                     if (Files.exists(var1x.resolve("instance.bson"))) {
                        Path var3 = var4.relativize(var1x);
                        String var4x = var3.toString();
                        var1.add(var4x);
                        class="kw">return FileVisitResult.SKIP_SUBTREE;
                     } else {
                        class="kw">return FileVisitResult.CONTINUE;
                     }
                  }
               });
            } catch (IOException var6) {
               throw SneakyThrow.sneakyThrow(var6);
            }
         }
      }

      class="kw">return var1;
   }

   class="kw">private class="kw">static void onPlayerConnect(@Nonnull PlayerConnectEvent var0) {
      Holder var1 = var0.getHolder();
      Player var2 = var1.getComponent(Player.getComponentType());
      assert var2 != null;
      PlayerConfigData var3 = var2.getPlayerConfigData();
      InstanceEntityConfig var4 = InstanceEntityConfig.ensureAndGet(var1);
      String var5 = var3.getWorld();
      World var6 = Universe.get().getWorld(var5);
      WorldReturnPoint var7 = var4.getReturnPoint();
      if (var7 != null && (var6 == null || var7.isReturnOnReconnect())) {
         var6 = Universe.get().getWorld(var7.getWorld());
         if (var6 != null) {
            Transform var8 = var7.getReturnPoint();
            TransformComponent var9 = var1.ensureAndGetComponent(TransformComponent.getComponentType());
            var9.setPosition(var8.getPosition());
            float var10 = var8.getRotation().yaw();
            if (Float.isFinite(var10)) {
               Rotation3f var11 = new Rotation3f(var9.getRotation());
               var11.setYaw(var10);
               var9.setRotation(var11);
            }

            HeadRotation var13 = var1.ensureAndGetComponent(HeadRotation.getComponentType());
            var13.teleportRotation(var8.getRotation());
         }
      } else if (var6 != null) {
         var4.setReturnPointOverride(var4.getReturnPoint());
      }
   }

   class="kw">private class="kw">static void onPlayerAddToWorld(@Nonnull AddPlayerToWorldEvent var0) {
      Holder var1 = var0.getHolder();
      InstanceWorldConfig var2 = InstanceWorldConfig.get(var0.getWorld().getWorldConfig());
      if (var2 == null) {
         InstanceEntityConfig var7 = var1.getComponent(InstanceEntityConfig.getComponentType());
         if (var7 != null && var7.getReturnPoint() != null) {
            var7.setReturnPoint(null);
            var7.clearReturnStack();
         }
      } else {
         InstanceEntityConfig var3 = InstanceEntityConfig.ensureAndGet(var1);
         WorldReturnPoint var4;
         if (var3.getReturnPointOverride() == null) {
            var4 = var2.getReturnPoint();
         } else {
            var4 = var3.getReturnPointOverride();
            var4.setReturnOnReconnect(var2.shouldPreventReconnection());
            var3.setReturnPointOverride(null);
         }

         if (var4 != null) {
            UUID var5 = var0.getWorld().getWorldConfig().getUuid();
            var3.dropReturnsInto(var5);
            WorldReturnPoint var6 = var3.getReturnPoint();
            if (var6 != null && !var6.getWorld().equals(var4.getWorld()) && !var6.getWorld().equals(var5)) {
               var3.pushReturnPoint(var6);
            }
         }

         var3.setReturnPoint(var4);
      }
   }

   class="kw">private class="kw">static void onPlayerReady(@Nonnull PlayerReadyEvent var0) {
      Player var1 = var0.getPlayer();
      World var2 = var1.getWorld();
      if (var2 != null) {
         WorldConfig var3 = var2.getWorldConfig();
         InstanceWorldConfig var4 = InstanceWorldConfig.get(var3);
         if (var4 != null) {
            InstanceDiscoveryConfig var5 = var4.getDiscovery();
            if (var5 != null) {
               PlayerConfigData var6 = var1.getPlayerConfigData();
               UUID var7 = var3.getUuid();
               if (var5.alwaysDisplay() || !var6.getDiscoveredInstances().contains(var7)) {
                  Set var8 = new HashSet<>(var6.getDiscoveredInstances());
                  var8.add(var7);
                  var6.setDiscoveredInstances(var8);
                  Ref var9 = var0.getPlayerRef();
                  if (var9.isValid()) {
                     var2.execute(() -> {
                        Store var4 = var2.getEntityStore().getStore();
                        showInstanceDiscovery(var9, var4, var7, var5);
                     });
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void showInstanceDiscovery(
      @Nonnull Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1, @Nonnull UUID var2, @Nonnull InstanceDiscoveryConfig var3
   ) {
      DiscoverInstanceEvent.Display var4 = new DiscoverInstanceEvent.Display(var2, var3.clone());
      var1.invoke(var0, var4);
      var3 = var4.getDiscoveryConfig();
      if (!var4.isCancelled() && var4.shouldDisplay()) {
         PlayerRef var5 = var1.getComponent(var0, PlayerRef.getComponentType());
         if (var5 != null) {
            String var6 = var3.getSubtitleKey();
            Message var7 = var6 != null ? Message.translation(var6) : Message.empty();
            EventTitleUtil.showEventTitleToPlayer(
               var5,
               Message.translation(var3.getTitleKey()),
               var7,
               var3.isMajor(),
               var3.getIcon(),
               var3.getDuration(),
               var3.getFadeInDuration(),
               var3.getFadeOutDuration()
            );
            String var8 = var3.getDiscoverySoundEventId();
            if (var8 != null) {
               int var9 = SoundEvent.getAssetMap().getIndex(var8);
               if (var9 != Integer.MIN_VALUE) {
                  SoundUtil.playSoundEvent2d(var0, var9, SoundCategory.UI, var1);
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void onPlayerDrainFromWorld(@Nonnull DrainPlayerFromWorldEvent var0) {
      InstanceEntityConfig var1 = InstanceEntityConfig.removeAndGet(var0.getHolder());
      if (var1 != null) {
         WorldReturnPoint var2 = var1.getReturnPoint();
         if (var2 != null) {
            World var3 = Universe.get().getWorld(var2.getWorld());
            if (var3 != null) {
               var0.setWorld(var3);
               var0.setTransform(var2.getReturnPoint());
            }
         }
      }
   }

   class="kw">private void validateInstanceAssets(@Nonnull LoadAssetEvent var1) {
      Path var2 = AssetModule.get().getBaseAssetPack().getRoot().resolve("Server").resolve("Instances");
      if (Options.getOptionSet().has(Options.VALIDATE_ASSETS) && Files.isDirectory(var2) && !var1.isShouldShutdown()) {
         StringBuilder var3 = new StringBuilder();

         for (String var6 : this.getInstanceAssets()) {
            StringBuilder var7 = new StringBuilder();
            Path var8 = getInstanceAssetPath(var6);
            Universe var9 = Universe.get();
            WorldConfig var10 = WorldConfig.load(var8.resolve("instance.bson")).join();
            IChunkStorageProvider var11 = var10.getChunkStorageProvider();
            var10.setChunkStorageProvider(new MigrationChunkStorageProvider(new IChunkStorageProvider[]{var11}, EmptyChunkStorageProvider.INSTANCE));
            var10.setResourceStorageProvider(EmptyResourceStorageProvider.INSTANCE);
            var10.setUuid(UUID.randomUUID());
            var10.setSavingPlayers(false);
            var10.setIsAllNPCFrozen(true);
            var10.setSavingConfig(false);
            var10.setTicking(false);
            var10.setGameMode(GameMode.Creative);
            var10.setDeleteOnRemove(false);
            var10.setCompassUpdating(false);
            InstanceWorldConfig.ensureAndGet(var10).setRemovalConditions(RemovalCondition.EMPTY);
            var10.markChanged();
            String var12 = "instance-validate-" + safeName(var6);

            try {
               World var13 = var9.makeWorld(var12, var8, var10, false).join();
               EnumSet var14 = EnumSet.of(ValidationOption.BLOCK_STATES, ValidationOption.BLOCKS);
               var13.validate(var7, WorldValidationUtil.blockValidator(var7, var14), var14);
            } catch (Exception var18) {
               var7.append("\t").append(var18.getMessage());
               ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var18)).log("Failed to validate: %s", var6);
            } class="kw">finally {
               if (!var7.isEmpty()) {
                  var3.append("Instance: ").append(var6).append('\n').append(var7).append('\n');
               }
            }

            if (var9.getWorld(var12) != null) {
               var9.removeWorld(var12);
            }
         }

         if (!var3.isEmpty()) {
            this.getLogger().at(Level.SEVERE).log("Failed to validate instances:\n%s", var3);
            var1.failed(true, "failed to validate instances");
         }

         HytaleLogger.getLogger()
            .at(Level.INFO)
            .log("Loading Instance assets phase completed! Boot time %s", FormatUtil.nanosToString(System.nanoTime() - var1.getBootStart()));
      }
   }

   @Nonnull
   class="kw">public class="kw">static String safeName(@Nonnull String var0) {
      class="kw">return var0.replace('/', '-');
   }

   @Nonnull
   class="kw">public ResourceType<ChunkStore, InstanceDataResource> getInstanceDataResourceType() {
      class="kw">return this.instanceDataResourceType;
   }

   @Nonnull
   class="kw">public ComponentType<EntityStore, InstanceEntityConfig> getInstanceEntityConfigComponentType() {
      class="kw">return this.instanceEntityConfigComponentType;
   }

   @Nonnull
   class="kw">public ComponentType<ChunkStore, InstanceBlock> getInstanceBlockComponentType() {
      class="kw">return this.instanceBlockComponentType;
   }

   @Nonnull
   class="kw">public ComponentType<ChunkStore, ConfigurableInstanceBlock> getConfigurableInstanceBlockComponentType() {
      class="kw">return this.configurableInstanceBlockComponentType;
   }
}