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

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.AssetStore;
class="kw">import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.action.EventAction;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.context.Context;
class="kw">import com.hypixel.hytale.builtin.buildertools.BuilderToolsPlugin;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.asset.TriggerEffectAsset;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.command.TriggerVolumeCommand;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.component.IgnoreTriggerVolumes;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.component.TriggerVolume;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.component.TriggerVolumeGroup;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEventType;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.CancelParticlesEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ControlDoorsEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.DamageEntityEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.DeleteVolumeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.DisableVolumeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.EnableVolumeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.EntityEffectEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.GiveItemEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ItemCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ModifyRulesEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ModifyTagsEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.PastePrefabEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.PlaceBlockEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.PlayAnimationEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.PlaySoundEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.PlayVfxEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.RemoveEntitiesEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ReplaceBlockTypeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.RunRootInteractionEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SendMessageEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SendSignalEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SetGameModeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SetMusicEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SetVelocityEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SetWeatherEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.ShowEventTitleEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.SpawnNpcEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.TeleportEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.TimeEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.TriggerNpcMarkersEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.BlockTypeCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.CooldownCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.EntityCountCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.GameModeCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.PermissionCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.PlayerCountCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.RandomChanceCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.TagCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.conditions.TimeOfDayCondition;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.CreativePlacementRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.DamageMultiplierRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.FlyRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoBuildRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDamageRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDestroyRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoDoorOpenRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoHarvestRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoHealRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoTickRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.builtin.rules.NoUseRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.interaction.DestroyTaggedVolumesInteraction;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.interaction.SignalNearbyVolumesInteraction;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.interaction.SpawnTriggerVolumeInteraction;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.GroupEntry;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.TriggerVolumeManager;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.VolumeEntry;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.npc.builders.BuilderActionSignalTaggedVolumes;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumeChunkRegenSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumeGroupWorldGenHandler;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumePasteHandler;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumePrefabContributor;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumePrefabPasteRemapSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.prefab.TriggerVolumeWorldGenHandler;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.shape.TriggerVolumeShape;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeBlockEventSystems;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeDeathSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeEntityRemoveSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeNoHealSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumePlayerStateSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeRuleSystems;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.system.TriggerVolumeTickingSystem;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.worldevent.TriggerVolumeContext;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.worldevent.TriggerVolumeCreateAction;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.worldevent.TriggerVolumeRemoveAction;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.component.ComponentRegistry;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdateTriggerVolumeDisplay;
class="kw">import com.hypixel.hytale.server.core.asset.HytaleAssetStore;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.buildertool.config.PrefabListAsset;
class="kw">import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
class="kw">import com.hypixel.hytale.server.core.asset.type.musiccontainer.config.MusicContainer;
class="kw">import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
class="kw">import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
class="kw">import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
class="kw">import com.hypixel.hytale.server.core.event.events.player.AddPlayerToWorldEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.PlayerDisconnectEvent;
class="kw">import com.hypixel.hytale.server.core.event.events.player.RemovedPlayerFromWorldEvent;
class="kw">import com.hypixel.hytale.server.core.io.ServerManager;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
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.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.modules.time.TimeResource;
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.prefab.PrefabStore;
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.TickSuppressionRegistry;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.RemoveWorldEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.StartWorldEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.WorldGenChunksClearedEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.Builder;
class="kw">import com.hypixel.hytale.server.npc.asset.builder.BuilderInfo;
class="kw">import com.hypixel.hytale.server.npc.util.expression.ExecutionContext;
class="kw">import com.hypixel.hytale.server.spawning.ISpawnableWithModel;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawnmarker.config.SpawnMarker;
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.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.EnumSet;
class="kw">import java.util.HashMap;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.LinkedHashSet;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Set;
class="kw">import java.util.TreeSet;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
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 TriggerVolumesPlugin class="kw">extends JavaPlugin {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static TriggerVolumesPlugin instance;
   class="kw">private ResourceType<EntityStore, TriggerVolumeManager> managerResourceType;
   class="kw">private ComponentType<EntityStore, TriggerVolume> triggerVolumeComponentType;
   class="kw">private ComponentType<EntityStore, TriggerVolumeGroup> triggerVolumeGroupComponentType;
   class="kw">private ComponentType<EntityStore, IgnoreTriggerVolumes> ignoreTriggerVolumesComponentType;
   class="kw">private TriggerVolumePlayerStateSystem playerStateSystem;
   class="kw">private class="kw">final Map<String, AssetSourceProvider> assetSources = new LinkedHashMap<>();
   class="kw">private class="kw">final Map<TriggerVolumesPlugin.AssetFieldKey, String> assetFieldMappings = new HashMap<>();
   class="kw">private class="kw">final Map<String, String> roleModelNameCache = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<UUID, TriggerVolumesPlugin.PastePrefabPreviewState> pastePrefabPreviewStates = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<UUID, EnumSet<TriggerVolumeManager.ViewSource>> pendingTransferSources = new ConcurrentHashMap<>();

   @Nonnull
   class="kw">public class="kw">static TriggerVolumesPlugin get() {
      class="kw">return instance;
   }

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

   class="kw">public <T class="kw">extends TriggerEffect> void registerEffectType(@Nonnull String var1, @Nonnull Class<T> var2, @Nonnull BuilderCodec<T> var3) {
      Objects.requireNonNull(var1, "typeId");
      Objects.requireNonNull(var2, "clazz");
      Objects.requireNonNull(var3, "codec");
      if (TriggerEffect.CODEC.getCodecFor(var1) != null) {
         throw new IllegalArgumentException("Trigger effect type '" + var1 + "' is already registered");
      }

      TriggerEffect.CODEC.register(var1, var2, var3);
      LOGGER.at(Level.INFO).log("Registered trigger effect type '%s' (%s)", var1, var2.getSimpleName());
   }

   class="kw">public <T class="kw">extends TriggerCondition> void registerConditionType(@Nonnull String var1, @Nonnull Class<T> var2, @Nonnull BuilderCodec<T> var3) {
      Objects.requireNonNull(var1, "typeId");
      Objects.requireNonNull(var2, "clazz");
      Objects.requireNonNull(var3, "codec");
      if (TriggerCondition.CODEC.getCodecFor(var1) != null) {
         throw new IllegalArgumentException("Trigger condition type '" + var1 + "' is already registered");
      }

      TriggerCondition.CODEC.register(var1, var2, var3);
      LOGGER.at(Level.INFO).log("Registered trigger condition type '%s' (%s)", var1, var2.getSimpleName());
   }

   class="kw">public <T class="kw">extends TriggerRule> void registerRuleType(@Nonnull String var1, @Nonnull Class<T> var2, @Nonnull BuilderCodec<T> var3) {
      Objects.requireNonNull(var1, "typeId");
      Objects.requireNonNull(var2, "clazz");
      Objects.requireNonNull(var3, "codec");
      if (TriggerRule.CODEC.getCodecFor(var1) != null) {
         throw new IllegalArgumentException("Trigger rule type '" + var1 + "' is already registered");
      }

      TriggerRule.CODEC.register(var1, var2, var3);
      LOGGER.at(Level.INFO).log("Registered trigger rule type '%s' (%s)", var1, var2.getSimpleName());
   }

   @Nonnull
   class="kw">public TriggerEventType registerEventType(@Nonnull String var1) {
      Objects.requireNonNull(var1, "typeId");
      if (TriggerEventType.get(var1) != null) {
         throw new IllegalArgumentException("Trigger event type '" + var1 + "' is already registered");
      }

      TriggerEventType var2 = TriggerEventType.register(var1);
      LOGGER.at(Level.INFO).log("Registered trigger event type '%s'", var1);
      class="kw">return var2;
   }

   class="kw">public void registerAssetSource(@Nonnull String var1, @Nonnull AssetSourceProvider var2) {
      Objects.requireNonNull(var1, "sourceId");
      Objects.requireNonNull(var2, "provider");
      this.assetSources.put(var1, var2);
   }

   class="kw">public void registerAssetField(@Nonnull String var1, @Nonnull String var2, @Nonnull String var3) {
      Objects.requireNonNull(var1, "effectTypeId");
      Objects.requireNonNull(var2, "fieldKey");
      Objects.requireNonNull(var3, "sourceId");
      this.assetFieldMappings.put(new TriggerVolumesPlugin.AssetFieldKey(var1, var2), var3);
   }

   @Nullable
   class="kw">public TriggerVolumesPlugin.PastePrefabPreviewState getPastePrefabPreviewState(@Nonnull UUID var1) {
      class="kw">return this.pastePrefabPreviewStates.get(var1);
   }

   class="kw">public void setPastePrefabPreviewState(@Nonnull UUID var1, @Nonnull TriggerVolumesPlugin.PastePrefabPreviewState var2) {
      this.pastePrefabPreviewStates.put(var1, var2);
   }

   class="kw">public void clearPastePrefabPreviewState(@Nonnull UUID var1) {
      this.pastePrefabPreviewStates.remove(var1);
   }

   @Nullable
   class="kw">public String getAssetSourceForField(@Nonnull String var1, @Nonnull String var2) {
      class="kw">return this.assetFieldMappings.get(new TriggerVolumesPlugin.AssetFieldKey(var1, var2));
   }

   @Nonnull
   class="kw">public Collection<String> getAssetIds(@Nonnull String var1) {
      AssetSourceProvider var2 = this.assetSources.get(var1);
      class="kw">return var2 == null ? List.of() : var2.getAssetIds().stream().filter(var0 -> !var0.startsWith("*")).toList();
   }

   @Nonnull
   class="kw">public ResourceType<EntityStore, TriggerVolumeManager> getManagerResourceType() {
      class="kw">return this.managerResourceType;
   }

   @Nonnull
   class="kw">public ComponentType<EntityStore, TriggerVolume> getTriggerVolumeComponentType() {
      class="kw">return this.triggerVolumeComponentType;
   }

   @Nonnull
   class="kw">public ComponentType<EntityStore, TriggerVolumeGroup> getTriggerVolumeGroupComponentType() {
      class="kw">return this.triggerVolumeGroupComponentType;
   }

   @Nonnull
   class="kw">public ComponentType<EntityStore, IgnoreTriggerVolumes> getIgnoreTriggerVolumesComponentType() {
      class="kw">return this.ignoreTriggerVolumesComponentType;
   }

   @Override
   class="kw">protected void setup() {
      instance = this;
      this.registerEffectTypes();
      AssetRegistry.register(
         ((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)((HytaleAssetStore.Builder)HytaleAssetStore.builder(
                        TriggerEffectAsset.class, new DefaultAssetMap()
                     )
                     .setPath("TriggerVolumes/Effects"))
                  .setCodec(TriggerEffectAsset.CODEC))
               .setKeyFunction(TriggerEffectAsset::getId))
            .build()
      );
      ComponentRegistry var1 = EntityStore.REGISTRY;
      this.managerResourceType = var1.registerResource(TriggerVolumeManager.class, "TriggerVolumeData", TriggerVolumeManager.CODEC);
      this.triggerVolumeComponentType = var1.registerComponent(TriggerVolume.class, "TriggerVolume", TriggerVolume.CODEC);
      this.triggerVolumeGroupComponentType = var1.registerComponent(TriggerVolumeGroup.class, "TriggerVolumeGroup", TriggerVolumeGroup.CODEC);
      this.ignoreTriggerVolumesComponentType = var1.registerComponent(IgnoreTriggerVolumes.class, "IgnoreTriggerVolumes", IgnoreTriggerVolumes.CODEC);
      EntityModule var2 = EntityModule.get();
      TriggerVolumeTickingSystem var3 = new TriggerVolumeTickingSystem(
         this.managerResourceType,
         var2.getPlayerSpatialResourceType(),
         var2.getEntitySpatialResourceType(),
         TimeResource.getResourceType(),
         TickSuppressionRegistry.RESOURCE
      );
      var1.registerSystem(var3);
      var1.registerSystem(new TriggerVolumeEntityRemoveSystem(var3, this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoBuild(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoDestroyBlockDamage(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoDestroyBlockBreak(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoDoorOpen(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoUseBlock(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoUseEntity(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.NoHarvestUse(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.CreativePlacement(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.DamageRuleFilter(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeRuleSystems.DamageMultiplier(this.managerResourceType));
      this.playerStateSystem = new TriggerVolumePlayerStateSystem(this.managerResourceType);
      var1.registerSystem(this.playerStateSystem);
      var1.registerSystem(new TriggerVolumeNoHealSystem(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeBlockEventSystems.BlockPlaced(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeBlockEventSystems.BlockBroken(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeBlockEventSystems.EnvironmentBlockBroken(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeBlockEventSystems.BlockUsed(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeBlockEventSystems.EntityUsed(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeDeathSystem(this.managerResourceType));
      var1.registerSystem(new TriggerVolumePasteHandler(this.managerResourceType, this.triggerVolumeComponentType, this.triggerVolumeGroupComponentType));
      var1.registerSystem(new TriggerVolumePrefabPasteRemapSystem(this.managerResourceType));
      var1.registerSystem(new TriggerVolumeWorldGenHandler(this.managerResourceType, this.triggerVolumeComponentType));
      var1.registerSystem(new TriggerVolumeGroupWorldGenHandler(this.managerResourceType, this.triggerVolumeGroupComponentType));
      this.getChunkStoreRegistry().registerSystem(new TriggerVolumeChunkRegenSystem(this.managerResourceType));
      this.getCodecRegistry(Interaction.CODEC).register("DestroyTaggedVolumes", DestroyTaggedVolumesInteraction.class, DestroyTaggedVolumesInteraction.CODEC);
      this.getCodecRegistry(Interaction.CODEC).register("SpawnTriggerVolume", SpawnTriggerVolumeInteraction.class, SpawnTriggerVolumeInteraction.CODEC);
      this.getCodecRegistry(Interaction.CODEC).register("SignalNearbyVolumes", SignalNearbyVolumesInteraction.class, SignalNearbyVolumesInteraction.CODEC);
      NPCPlugin.get().registerCoreComponentType("SignalTaggedVolumes", BuilderActionSignalTaggedVolumes::new);
      this.getCodecRegistry(Context.TYPE_CODEC).register("TriggerVolumeContext", TriggerVolumeContext.class, TriggerVolumeContext.CODEC);
      this.getCodecRegistry(EventAction.TYPE_CODEC)
         .register("TriggerVolumeCreateAction", TriggerVolumeCreateAction.class, TriggerVolumeCreateAction.CODEC)
         .register("TriggerVolumeRemoveAction", TriggerVolumeRemoveAction.class, TriggerVolumeRemoveAction.CODEC);
      this.getCommandRegistry().registerCommand(new TriggerVolumeCommand());
      ServerManager.get().registerSubPacketHandlers(TriggerVolumeToolPacketHandler::new);
      this.getEventRegistry().registerGlobal(StartWorldEvent.class, var1x -> this.initManagerForWorld(var1x.getWorld()));
      this.getEventRegistry().registerGlobal(RemoveWorldEvent.class, this::onWorldRemoved);
      this.getEventRegistry().registerGlobal(WorldGenChunksClearedEvent.class, this::onWorldGenChunksCleared);
      this.getEventRegistry().registerGlobal(RemovedPlayerFromWorldEvent.class, this::onPlayerRemovedFromWorld);
      this.getEventRegistry().registerGlobal(AddPlayerToWorldEvent.class, this::onPlayerAddedToWorld);
      this.getEventRegistry().registerGlobal(PlayerDisconnectEvent.class, this::onPlayerDisconnect);
   }

   @Override
   class="kw">protected void start() {
      BuilderToolsPlugin var1 = BuilderToolsPlugin.get();
      var1.registerPrefabSaveContributor(new TriggerVolumePrefabContributor());
      var1.registerClipboardContributor(new TriggerVolumePrefabContributor());
      var1.setBuilderToolModeDeactivatedCallback((var1x, var2) -> {
         World var3 = var2.getExternalData().getWorld();
         if (var3 != null) {
            TriggerVolumeManager var4 = var3.getEntityStore().getStore().getResource(this.managerResourceType);
            if (var4 != null) {
               var4.removeViewer(var1x.getUuid(), TriggerVolumeManager.ViewSource.SELECTION_TOOL);
               if (!var4.isViewing(var1x.getUuid())) {
                  var1x.getPacketHandler().write(new UpdateTriggerVolumeDisplay());
               } else {
                  var4.sendVolumeDisplay(var1x);
               }
            }
         }
      });
   }

   @Override
   class="kw">protected void shutdown() {
   }

   class="kw">private void onWorldRemoved(@Nonnull RemoveWorldEvent var1) {
      TriggerVolumeManager var2 = this.getManager(var1.getWorld());
      if (var2 != null) {
         for (UUID var4 : var2.getViewerUuids()) {
            this.pendingTransferSources.remove(var4);
            PlayerRef var5 = Universe.get().getPlayer(var4);
            if (var5 != null) {
               var5.getPacketHandler().write(new UpdateTriggerVolumeDisplay());
            }
         }

         var2.clearViewers();
      }
   }

   class="kw">private void onWorldGenChunksCleared(@Nonnull WorldGenChunksClearedEvent var1) {
      TriggerVolumeManager var2 = this.getManager(var1.getWorld());
      if (var2 != null) {
         var2.removeAllVolumes();
      }
   }

   class="kw">private void onPlayerRemovedFromWorld(@Nonnull RemovedPlayerFromWorldEvent var1) {
      PlayerRef var2 = var1.getHolder().getComponent(PlayerRef.getComponentType());
      if (var2 != null) {
         this.playerStateSystem.revertPlayer(var1.getHolder());
         TriggerVolumeManager var3 = this.getManager(var1.getWorld());
         if (var3 != null) {
            UUID var4 = var2.getUuid();
            EnumSet var5 = var3.peekViewerSources(var4);
            if (var5 != null && !var5.isEmpty()) {
               this.pendingTransferSources.put(var4, var5);
               var2.getPacketHandler().write(new UpdateTriggerVolumeDisplay());
            } else {
               this.pendingTransferSources.remove(var4);
            }

            clearViewerState(var3, var4);
         }
      }
   }

   class="kw">private void onPlayerAddedToWorld(@Nonnull AddPlayerToWorldEvent var1) {
      PlayerRef var2 = var1.getHolder().getComponent(PlayerRef.getComponentType());
      if (var2 != null) {
         TriggerVolumeManager var3 = this.getManager(var1.getWorld());
         if (var3 != null) {
            var3.sendClientRuleVolumes(var2);
            EnumSet var4 = this.pendingTransferSources.remove(var2.getUuid());
            if (var4 != null && !var4.isEmpty()) {
               for (TriggerVolumeManager.ViewSource var6 : var4) {
                  var3.addViewer(var2.getUuid(), var6);
               }

               var3.sendVolumeDisplay(var2);
            }
         }
      }
   }

   class="kw">private void onPlayerDisconnect(@Nonnull PlayerDisconnectEvent var1) {
      this.pendingTransferSources.remove(var1.getPlayerRef().getUuid());
      this.playerStateSystem.forgetPlayer(var1.getPlayerRef().getUuid());
   }

   class="kw">private class="kw">static void clearViewerState(@Nonnull TriggerVolumeManager var0, @Nonnull UUID var1) {
      for (TriggerVolumeManager.ViewSource var5 : TriggerVolumeManager.ViewSource.values()) {
         var0.removeViewer(var1, var5);
      }

      var0.setPlayerSelection(var1, null);
   }

   @Nullable
   class="kw">private TriggerVolumeManager getManager(@Nonnull World var1) {
      Store var2 = var1.getEntityStore().getStore();
      class="kw">return var2 == null ? null : var2.getResource(this.managerResourceType);
   }

   class="kw">private void registerEffectTypes() {
      TriggerVolumeShape.registerBuiltinShapes();
      TriggerCondition.CODEC.register("PermissionCondition", PermissionCondition.class, PermissionCondition.CODEC);
      TriggerCondition.CODEC.register("CooldownCondition", CooldownCondition.class, CooldownCondition.CODEC);
      TriggerCondition.CODEC.register("GameModeCondition", GameModeCondition.class, GameModeCondition.CODEC);
      TriggerCondition.CODEC.register("ItemCondition", ItemCondition.class, ItemCondition.CODEC);
      TriggerCondition.CODEC.register("RandomChanceCondition", RandomChanceCondition.class, RandomChanceCondition.CODEC);
      TriggerCondition.CODEC.register("PlayerCountCondition", PlayerCountCondition.class, PlayerCountCondition.CODEC);
      TriggerCondition.CODEC.register("TagCondition", TagCondition.class, TagCondition.CODEC);
      TriggerCondition.CODEC.register("BlockTypeCondition", BlockTypeCondition.class, BlockTypeCondition.CODEC);
      TriggerCondition.CODEC.register("EntityCountCondition", EntityCountCondition.class, EntityCountCondition.CODEC);
      TriggerCondition.CODEC.register("TimeOfDay", TimeOfDayCondition.class, TimeOfDayCondition.CODEC);
      TriggerEffect.CODEC.register("Teleport", TeleportEffect.class, TeleportEffect.CODEC);
      TriggerEffect.CODEC.register("SendMessage", SendMessageEffect.class, SendMessageEffect.CODEC);
      TriggerEffect.CODEC.register("PlaySound", PlaySoundEffect.class, PlaySoundEffect.CODEC);
      TriggerEffect.CODEC.register("SetVelocity", SetVelocityEffect.class, SetVelocityEffect.CODEC);
      TriggerEffect.CODEC.register("EntityEffect", EntityEffectEffect.class, EntityEffectEffect.CODEC);
      TriggerEffect.CODEC.register("TriggerNpcMarkers", TriggerNpcMarkersEffect.class, TriggerNpcMarkersEffect.CODEC);
      TriggerEffect.CODEC.register("PlayVfx", PlayVfxEffect.class, PlayVfxEffect.CODEC);
      TriggerEffect.CODEC.register("SetWeather", SetWeatherEffect.class, SetWeatherEffect.CODEC);
      TriggerEffect.CODEC.register("Time", TimeEffect.class, TimeEffect.CODEC);
      TriggerEffect.CODEC.register("ShowEventTitle", ShowEventTitleEffect.class, ShowEventTitleEffect.CODEC);
      TriggerEffect.CODEC.register("PastePrefab", PastePrefabEffect.class, PastePrefabEffect.CODEC);
      TriggerEffect.CODEC.register("ControlDoors", ControlDoorsEffect.class, ControlDoorsEffect.CODEC);
      TriggerEffect.CODEC.register("EnableVolume", EnableVolumeEffect.class, EnableVolumeEffect.CODEC);
      TriggerEffect.CODEC.register("DisableVolume", DisableVolumeEffect.class, DisableVolumeEffect.CODEC);
      TriggerEffect.CODEC.register("DeleteVolume", DeleteVolumeEffect.class, DeleteVolumeEffect.CODEC);
      TriggerEffect.CODEC.register("DamageEntity", DamageEntityEffect.class, DamageEntityEffect.CODEC);
      TriggerEffect.CODEC.register("RemoveEntities", RemoveEntitiesEffect.class, RemoveEntitiesEffect.CODEC);
      TriggerEffect.CODEC.register("CancelParticles", CancelParticlesEffect.class, CancelParticlesEffect.CODEC);
      TriggerEffect.CODEC.register("RunRootInteraction", RunRootInteractionEffect.class, RunRootInteractionEffect.CODEC);
      TriggerEffect.CODEC.register("SetMusic", SetMusicEffect.class, SetMusicEffect.CODEC);
      TriggerEffect.CODEC.register("GiveItem", GiveItemEffect.class, GiveItemEffect.CODEC);
      TriggerEffect.CODEC.register("SetGameMode", SetGameModeEffect.class, SetGameModeEffect.CODEC);
      TriggerEffect.CODEC.register("ModifyTags", ModifyTagsEffect.class, ModifyTagsEffect.CODEC);
      TriggerEffect.CODEC.register("SendSignal", SendSignalEffect.class, SendSignalEffect.CODEC);
      TriggerEffect.CODEC.register("PlaceBlock", PlaceBlockEffect.class, PlaceBlockEffect.CODEC);
      TriggerEffect.CODEC.register("ReplaceBlockType", ReplaceBlockTypeEffect.class, ReplaceBlockTypeEffect.CODEC);
      TriggerEffect.CODEC.register("SpawnNpc", SpawnNpcEffect.class, SpawnNpcEffect.CODEC);
      TriggerEffect.CODEC.register("PlayAnimation", PlayAnimationEffect.class, PlayAnimationEffect.CODEC);
      TriggerEffect.CODEC.register("ModifyRules", ModifyRulesEffect.class, ModifyRulesEffect.CODEC);
      TriggerRule.CODEC.register("NoBuild", NoBuildRule.class, NoBuildRule.CODEC);
      TriggerRule.CODEC.register("NoDestroy", NoDestroyRule.class, NoDestroyRule.CODEC);
      TriggerRule.CODEC.register("NoHarvest", NoHarvestRule.class, NoHarvestRule.CODEC);
      TriggerRule.CODEC.register("NoDamage", NoDamageRule.class, NoDamageRule.CODEC);
      TriggerRule.CODEC.register("NoDoorOpen", NoDoorOpenRule.class, NoDoorOpenRule.CODEC);
      TriggerRule.CODEC.register("NoUse", NoUseRule.class, NoUseRule.CODEC);
      TriggerRule.CODEC.register("NoHeal", NoHealRule.class, NoHealRule.CODEC);
      TriggerRule.CODEC.register("DamageMultiplier", DamageMultiplierRule.class, DamageMultiplierRule.CODEC);
      TriggerRule.CODEC.register("Fly", FlyRule.class, FlyRule.CODEC);
      TriggerRule.CODEC.register("CreativePlacement", CreativePlacementRule.class, CreativePlacementRule.CODEC);
      TriggerRule.CODEC.register("NoTick", NoTickRule.class, NoTickRule.CODEC);
      TickSuppressionRegistry.ensureRegistered();
      this.registerAssetSource("BlockType", () -> BlockType.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("EntityEffect", () -> EntityEffect.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("Item", () -> Item.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("BlockOrItem", TriggerVolumesPlugin::collectBlockAndItemIds);
      this.registerAssetSource("SoundEvent", () -> SoundEvent.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("EffectAsset", () -> {
         AssetStore var0 = AssetRegistry.getAssetStore(TriggerEffectAsset.class);
         class="kw">return var0 != null ? ((DefaultAssetMap)var0.getAssetMap()).getAssetMap().keySet() : Set.of();
      });
      this.registerAssetSource("Weather", () -> Weather.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("PrefabList", () -> PrefabListAsset.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("Prefab", TriggerVolumesPlugin::collectPrefabRelPaths);
      this.registerAssetSource("ParticleSystem", () -> ParticleSystem.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("ManualSpawnMarker", TriggerVolumesPlugin::collectManualSpawnMarkerIds);
      this.registerAssetSource("RootInteraction", () -> RootInteraction.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("MusicContainer", () -> MusicContainer.getAssetMap().getAssetMap().keySet());
      this.registerAssetSource("NpcRole", () -> NPCPlugin.get().getRoleTemplateNames(true));
      this.registerAssetSource("Animation", TriggerVolumesPlugin::collectAnimationIds);
      this.registerAssetSource("AnimationApplyOn", this::collectApplyOnIds);
      this.registerAssetSource("RuleEntity", TriggerVolumesPlugin::collectRuleEntityIds);
      this.registerAssetField("EntityEffect", "Effect", "EntityEffect");
      this.registerAssetField("PlaySound", "SoundEvent", "SoundEvent");
      this.registerAssetField("SetWeather", "Weather", "Weather");
      this.registerAssetField("PastePrefab", "PrefabList", "PrefabList");
      this.registerAssetField("PastePrefab", "Prefab", "Prefab");
      this.registerAssetField("PlayVfx", "ParticleSystem", "ParticleSystem");
      this.registerAssetField("CancelParticles", "ParticleSystems", "ParticleSystem");
      this.registerAssetField("TriggerNpcMarkers", "MarkerType", "ManualSpawnMarker");
      this.registerAssetField("RunRootInteraction", "RootInteraction", "RootInteraction");
      this.registerAssetField("SetMusic", "MusicContainer", "MusicContainer");
      this.registerAssetField("GiveItem", "Item", "Item");
      this.registerAssetField("PlaceBlock", "BlockType", "BlockType");
      this.registerAssetField("ReplaceBlockType", "FromBlockTypes", "BlockType");
      this.registerAssetField("ReplaceBlockType", "ToBlockType", "BlockType");
      this.registerAssetField("ItemCondition", "Item", "Item");
      this.registerAssetField("BlockTypeCondition", "BlockType", "BlockType");
      this.registerAssetField("EntityCountCondition", "EntityType", "NpcRole");
      this.registerAssetField("SpawnNpc", "NpcType", "NpcRole");
      this.registerAssetField("RemoveEntities", "Roles", "NpcRole");
      this.registerAssetField("PlayAnimation", "Animation", "Animation");
      this.registerAssetField("PlayAnimation", "NpcType", "AnimationApplyOn");
      this.registerAssetField("NoBuild", "ExceptBlocks", "BlockType");
      this.registerAssetField("NoDestroy", "ExceptBlocks", "BlockType");
      this.registerAssetField("NoDestroy", "ExceptTools", "Item");
      this.registerAssetField("NoHarvest", "ExceptBlocks", "BlockType");
      this.registerAssetField("NoUse", "ExceptBlocks", "BlockOrItem");
      this.registerAssetField("NoDamage", "Entities", "RuleEntity");
      this.registerAssetField("DamageMultiplier", "Entities", "RuleEntity");
   }

   @Nonnull
   class="kw">private class="kw">static Collection<String> collectRuleEntityIds() {
      ArrayList var0 = new ArrayList<>();
      var0.add("Player");
      var0.addAll(NPCPlugin.get().getRoleTemplateNames(true));
      class="kw">return var0;
   }

   @Nonnull
   class="kw">private class="kw">static Collection<String> collectBlockAndItemIds() {
      LinkedHashSet var0 = new LinkedHashSet<>(BlockType.getAssetMap().getAssetMap().keySet());
      var0.addAll(Item.getAssetMap().getAssetMap().keySet());
      class="kw">return var0;
   }

   @Nonnull
   class="kw">private class="kw">static Collection<String> collectAnimationIds() {
      TreeSet var0 = new TreeSet<>();

      for (ModelAsset var2 : ModelAsset.getAssetMap().getAssetMap().values()) {
         if (var2 != null) {
            var0.addAll(var2.getAnimationSetMap().keySet());
         }
      }

      class="kw">return var0;
   }

   @Nonnull
   class="kw">private Collection<String> collectApplyOnIds() {
      ArrayList var1 = new ArrayList<>();
      var1.add("Player");
      var1.add("Everyone");
      var1.addAll(NPCPlugin.get().getRoleTemplateNames(true));
      class="kw">return var1;
   }

   @Nonnull
   class="kw">public Collection<String> collectAnimationIdsForApplyOn(@Nonnull String var1) {
      if (var1.isBlank()) {
         class="kw">return collectAnimationIds();
      }

      if ("Everyone".equals(var1)) {
         class="kw">return this.collectCommonAnimationIds();
      }

      ModelAsset var2 = this.resolveConcreteModel(var1);
      class="kw">return var2 == null ? collectAnimationIds() : new TreeSet<>(var2.getAnimationSetMap().keySet());
   }

   @Nonnull
   class="kw">public Collection<String> collectApplyOnIdsForAnimation(@Nonnull String var1) {
      ArrayList var2 = new ArrayList<>();
      ModelAsset var3 = ModelAsset.getAssetMap().getAsset("Player");
      if (var3 != null && var3.getAnimationSetMap().containsKey(var1)) {
         var2.add("Player");
      }

      if (this.collectCommonAnimationIds().contains(var1)) {
         var2.add("Everyone");
      }

      for (String var5 : NPCPlugin.get().getRoleTemplateNames(true)) {
         String var6 = this.resolveRoleModelName(var5);
         if (var6 != null) {
            ModelAsset var7 = ModelAsset.getAssetMap().getAsset(var6);
            if (var7 != null && var7.getAnimationSetMap().containsKey(var1)) {
               var2.add(var5);
            }
         }
      }

      class="kw">return var2;
   }

   class="kw">public boolean isLoopingAnimation(@Nonnull String var1, @Nonnull String var2) {
      ModelAsset var3 = this.resolveConcreteModel(var1);
      if (var3 == null) {
         class="kw">return false;
      }

      ModelAsset.AnimationSet var4 = var3.getAnimationSetMap().get(var2);
      if (var4 != null && var4.getAnimations() != null) {
         for (ModelAsset.Animation var8 : var4.getAnimations()) {
            if (var8.isLooping()) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      } else {
         class="kw">return false;
      }
   }

   @Nullable
   class="kw">private ModelAsset resolveConcreteModel(@Nonnull String var1) {
      if ("Player".equals(var1)) {
         class="kw">return ModelAsset.getAssetMap().getAsset("Player");
      }

      String var2 = this.resolveRoleModelName(var1);
      class="kw">return var2 != null ? ModelAsset.getAssetMap().getAsset(var2) : null;
   }

   @Nonnull
   class="kw">private Collection<String> collectCommonAnimationIds() {
      TreeSet var1 = null;
      ModelAsset var2 = ModelAsset.getAssetMap().getAsset("Player");
      if (var2 != null) {
         var1 = new TreeSet<>(var2.getAnimationSetMap().keySet());
      }

      for (String var4 : NPCPlugin.get().getRoleTemplateNames(true)) {
         String var5 = this.resolveRoleModelName(var4);
         if (var5 != null) {
            ModelAsset var6 = ModelAsset.getAssetMap().getAsset(var5);
            if (var6 != null) {
               Set var7 = var6.getAnimationSetMap().keySet();
               if (var1 == null) {
                  var1 = new TreeSet<>(var7);
               } else {
                  var1.retainAll(var7);
               }

               if (var1.isEmpty()) {
                  break;
               }
            }
         }
      }

      class="kw">return var1 == null ? collectAnimationIds() : var1;
   }

   @Nullable
   class="kw">private String resolveRoleModelName(@Nonnull String var1) {
      String var2 = this.roleModelNameCache.computeIfAbsent(var1, this::computeRoleModelName);
      class="kw">return var2.isEmpty() ? null : var2;
   }

   @Nonnull
   class="kw">private String computeRoleModelName(@Nonnull String var1) {
      NPCPlugin var2 = NPCPlugin.get();
      BuilderInfo var3 = var2.getRoleBuilderInfo(var2.getIndex(var1));
      if (var3 == null) {
         class="kw">return "";
      }

      Builder var4 = var3.getBuilder();
      if (var4.isSpawnable() && var4 class="kw">instanceof ISpawnableWithModel var5) {
         try {
            ExecutionContext var6 = new ExecutionContext(var4.getBuilderParameters().createScope());
            String var7 = var5.getSpawnModelName(var6, var5.createModifierScope(var6));
            class="kw">return var7 != null ? var7 : "";
         } catch (RuntimeException var8) {
            class="kw">return "";
         }
      } else {
         class="kw">return "";
      }
   }

   @Nonnull
   class="kw">private class="kw">static Collection<String> collectPrefabRelPaths() {
      TreeSet var0 = new TreeSet<>();
      PrefabStore var1 = PrefabStore.get();

      for (PrefabStore.AssetPackPrefabPath var3 : var1.getAllAssetPrefabPaths()) {
         Path var4 = var3.prefabsPath();

         try (Stream var5 = Files.walk(var4)) {
            var5.filter(PrefabStore.PREFAB_FILTER).forEach(var2 -> {
               Path var3 = var4.relativize(var2);
               var0.add(PrefabStore.stripPrefabSuffix(var3.toString().replace('\\', '/')));
            });
         } catch (Exception var10) {
            ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var10)).log("Failed to enumerate prefabs under %s", var4);
         }
      }

      class="kw">return var0;
   }

   @Nonnull
   class="kw">private class="kw">static Collection<String> collectManualSpawnMarkerIds() {
      ArrayList var0 = new ArrayList<>();

      for (Entry var2 : SpawnMarker.getAssetMap().getAssetMap().entrySet()) {
         if (var2.getValue().isManualTrigger()) {
            var0.add(var2.getKey());
         }
      }

      Collections.sort(var0);
      class="kw">return var0;
   }

   class="kw">private void initManagerForWorld(@Nonnull World var1) {
      String var2 = var1.getName().toLowerCase(Locale.ROOT);
      Store var3 = var1.getEntityStore().getStore();
      TriggerVolumeManager var4 = var3.getResource(this.managerResourceType);
      if (var4 != null) {
         var4.setWorld(var1);
         AssetStore var5 = AssetRegistry.getAssetStore(TriggerEffectAsset.class);

         for (VolumeEntry var7 : var4.getVolumesMap().values()) {
            var7.setWorldName(var2);
            if (var7.getEffectAssetRef() != null && var5 != null) {
               TriggerEffectAsset var8 = (TriggerEffectAsset)((DefaultAssetMap)var5.getAssetMap()).getAsset(var7.getEffectAssetRef());
               if (var8 == null) {
                  LOGGER.at(Level.WARNING).log("Volume '%s' references missing effect asset '%s'", var7.getId(), var7.getEffectAssetRef());
               } else {
                  var7.getConditions().clear();
                  var7.getConditions().addAll(Arrays.asList(var8.getConditions()));
                  var7.getEffects().clear();
                  var7.getEffects().addAll(Arrays.asList(var8.getEffects()));
                  var7.getRejectionEffects().clear();
                  var7.getRejectionEffects().addAll(Arrays.asList(var8.getRejectionEffects()));
                  var7.getRules().clear();
                  var7.getRules().addAll(Arrays.asList(var8.getRules()));
               }
            }
         }

         for (GroupEntry var10 : var4.getGroupsMap().values()) {
            var10.setWorldName(var2);
         }

         LOGGER.at(Level.INFO).log("Loaded %d trigger volumes and %d groups for world '%s'", var4.getVolumesMap().size(), var4.getGroupsMap().size(), var2);
      }
   }

   class="kw">private record AssetFieldKey(@Nonnull String typeId, @Nonnull String fieldKey) {
      class="kw">private AssetFieldKey {
      }
   }

   class="kw">public class="kw">static class="kw">final class PastePrefabPreviewState {
      @Nonnull
      class="kw">private class="kw">final String worldName;
      @Nullable
      class="kw">private class="kw">final String selectedId;
      class="kw">private class="kw">final boolean selectedIsGroup;
      @Nonnull
      class="kw">private class="kw">final String effectListKind;
      class="kw">private class="kw">final int effectIndex;
      @Nullable
      class="kw">private Vector3d lastSentPosition;

      class="kw">public PastePrefabPreviewState(@Nonnull String var1, @Nullable String var2, boolean var3, @Nonnull String var4, int var5, @Nullable Vector3d var6) {
         this.worldName = var1;
         this.selectedId = var2;
         this.selectedIsGroup = var3;
         this.effectListKind = var4;
         this.effectIndex = var5;
         this.lastSentPosition = var6 != null ? new Vector3d(var6) : null;
      }

      class="kw">public boolean matches(@Nonnull String var1, @Nullable String var2, boolean var3, @Nonnull String var4, int var5) {
         class="kw">return this.worldName.equals(var1)
            && Objects.equals(this.selectedId, var2)
            && this.selectedIsGroup == var3
            && this.effectListKind.equals(var4)
            && this.effectIndex == var5;
      }

      @Nonnull
      class="kw">public String worldName() {
         class="kw">return this.worldName;
      }

      @Nullable
      class="kw">public String selectedId() {
         class="kw">return this.selectedId;
      }

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

      @Nonnull
      class="kw">public String effectListKind() {
         class="kw">return this.effectListKind;
      }

      class="kw">public int effectIndex() {
         class="kw">return this.effectIndex;
      }

      @Nullable
      class="kw">public Vector3d lastSentPosition() {
         class="kw">return this.lastSentPosition != null ? new Vector3d(this.lastSentPosition) : null;
      }

      class="kw">public void setLastSentPosition(@Nonnull Vector3d var1) {
         this.lastSentPosition = new Vector3d(var1);
      }
   }
}