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

class="kw">import com.hypixel.hytale.builtin.buildertools.BuilderToolsPlugin;
class="kw">import com.hypixel.hytale.builtin.buildertools.snapshot.SelectionSnapshot;
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.TriggerRule;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.ConditionTiming;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.CooldownMode;
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.shape.BoxShape;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.shape.CylinderShape;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.shape.SphereShape;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.shape.TriggerVolumeShape;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.snapshot.TriggerVolumeGroupSnapshot;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.snapshot.TriggerVolumeSnapshot;
class="kw">import com.hypixel.hytale.component.Ref;
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.SelectionToolShowTriggerVolumes;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeConditionTiming;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeShapeType;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolCreate;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolCreateResponse;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolDelete;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolDuplicate;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolEquip;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolGroupCreate;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolGroupCreateResponse;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolGroupMove;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolMove;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolMultiMove;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolResize;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolRotate;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSelect;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetActivationDelay;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetCancelDelayedOnExit;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetColor;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetConditionTiming;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetCooldown;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetKeepLoaded;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetName;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolSetTargetTypes;
class="kw">import com.hypixel.hytale.protocol.packets.player.TriggerVolumeToolUngroup;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdateTriggerVolumeDisplay;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.io.handlers.IPacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.handlers.IWorldPacketHandler;
class="kw">import com.hypixel.hytale.server.core.io.handlers.SubPacketHandler;
class="kw">import com.hypixel.hytale.server.core.permissions.HytalePermissions;
class="kw">import com.hypixel.hytale.server.core.permissions.PermissionsModule;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.ArrayList;
class="kw">import java.util.EnumSet;
class="kw">import java.util.HashMap;
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.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ThreadLocalRandom;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3f;

class="kw">public class TriggerVolumeToolPacketHandler class="kw">implements SubPacketHandler {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final int MaxBatchSize = 4096;
   class="kw">private class="kw">static class="kw">final double MAX_SHAPE_EXTENT = 1000000.0;
   class="kw">private class="kw">static class="kw">final int[] GROUP_COLORS = new int[]{10506448, 4239424, 13656208, 14708784, 12599424};
   @Nonnull
   class="kw">private class="kw">final IPacketHandler packetHandler;

   class="kw">public TriggerVolumeToolPacketHandler(@Nonnull IPacketHandler var1) {
      this.packetHandler = var1;
   }

   class="kw">private class="kw">static boolean hasPermission(@Nonnull PlayerRef var0) {
      class="kw">return PermissionsModule.get().hasPermission(var0.getUuid(), HytalePermissions.BUILDER_TOOLS_EDITOR);
   }

   @Nonnull
   class="kw">private class="kw">static String generateId(@Nonnull TriggerVolumeManager var0) {
      String var1;
      do {
         var1 = UUID.randomUUID().toString();
      } while (var0.hasVolume(var1));

      class="kw">return var1;
   }

   class="kw">private class="kw">static void ensureViewing(@Nonnull PlayerRef var0, @Nonnull TriggerVolumeManager var1) {
      var1.addViewer(var0.getUuid(), TriggerVolumeManager.ViewSource.TOOL);
   }

   @Nonnull
   class="kw">static List<String> sanitizeBatch(@Nullable String[] var0) {
      if (var0 != null && var0.length != 0) {
         LinkedHashSet var1 = new LinkedHashSet<>();

         for (String var5 : var0) {
            if (var5 != null) {
               var1.add(var5);
               if (var1.size() >= 4096) {
                  break;
               }
            }
         }

         class="kw">return List.copyOf(var1);
      } else {
         class="kw">return List.of();
      }
   }

   @Nullable
   class="kw">private class="kw">static BuilderToolsPlugin.BuilderState getBuilderState(@Nonnull Store<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull PlayerRef var2) {
      Player var3 = var0.getComponent(var1, Player.getComponentType());
      class="kw">return var3 == null ? null : BuilderToolsPlugin.getState(var3, var2);
   }

   class="kw">private class="kw">static void recordHistory(
      @Nonnull Store<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull PlayerRef var2, @Nonnull SelectionSnapshot<?> var3
   ) {
      BuilderToolsPlugin.BuilderState var4 = getBuilderState(var0, var1, var2);
      if (var4 != null) {
         var4.pushTriggerVolumeHistory(var3);
      }
   }

   class="kw">private class="kw">static void recordHistory(
      @Nonnull Store<EntityStore> var0, @Nonnull Ref<EntityStore> var1, @Nonnull PlayerRef var2, @Nonnull List<SelectionSnapshot<?>> var3
   ) {
      if (!var3.isEmpty()) {
         BuilderToolsPlugin.BuilderState var4 = getBuilderState(var0, var1, var2);
         if (var4 != null) {
            var4.pushTriggerVolumeHistory(var3);
         }
      }
   }

   @Override
   class="kw">public void registerHandlers() {
      IWorldPacketHandler.registerHandler(this.packetHandler, 484, this::handleEquip, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 480, this::handleCreate, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 505, this::handleDuplicate, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 481, this::handleMove, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 482, this::handleResize, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 524, this::handleRotate, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 483, this::handleDelete, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 486, this::handleGroupCreate, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 488, this::handleUngroup, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 489, this::handleGroupMove, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 490, this::handleSelect, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 491, this::handleMultiMove, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 492, this::handleSetColor, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 526, this::handleSetName, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 493, this::handleSetTargetTypes, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 500, this::handleSetKeepLoaded, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 501, this::handleSetCooldown, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 502, this::handleSetActivationDelay, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 504, this::handleSetCancelDelayedOnExit, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 506, this::handleSetConditionTiming, TriggerVolumeToolPacketHandler::hasPermission);
      IWorldPacketHandler.registerHandler(this.packetHandler, 503, this::handleSelectionToolShowTriggerVolumes, TriggerVolumeToolPacketHandler::hasPermission);
   }

   class="kw">private void handleEquip(
      @Nonnull TriggerVolumeToolEquip var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         UUID var8 = var2.getUuid();
         if (var1.active) {
            var7.addViewer(var8, TriggerVolumeManager.ViewSource.TOOL);
            var7.sendVolumeDisplay(var2);
         } else {
            var7.removeViewer(var8, TriggerVolumeManager.ViewSource.TOOL);
            if (!var7.isViewing(var8)) {
               var2.getPacketHandler().write(new UpdateTriggerVolumeDisplay());
            }
         }
      }
   }

   class="kw">private void handleCreate(
      @Nonnull TriggerVolumeToolCreate var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         String var8 = var4.getName().toLowerCase(Locale.ROOT);
         Vector3d var9 = new Vector3d(var1.position.x(), var1.position.y(), var1.position.z());
         TriggerVolumeShape var10 = buildShape(
            var1.shapeType,
            var1.param1.x(),
            var1.param1.y(),
            var1.param1.z(),
            var1.param2 != null ? var1.param2.x() : 0.0F,
            var1.param2 != null ? var1.param2.y() : 0.0F,
            var1.param2 != null ? var1.param2.z() : 0.0F,
            var1.param2 != null
         );
         if (var10 == null) {
            LOGGER.at(Level.WARNING).log("Invalid shape type from %s", var2.getUuid());
         } else {
            String var11 = var1.name;
            if (var11 == null || var11.isBlank()) {
               var11 = generateId(var7);
            }

            if (var7.hasVolume(var11)) {
               var11 = generateId(var7);
            }

            VolumeEntry var12 = new VolumeEntry(var11, var8, var9, var10, new ArrayList<>(), EnumSet.of(EntityTargetType.PLAYER), true);
            var7.register(var11, var12);
            var7.notifyViewersAdd(var12);
            var7.enqueueVolumeCreateEvent(var12, var3, var2.getUuid());
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofCreate(var12));
            TriggerVolumeToolCreateResponse var13 = new TriggerVolumeToolCreateResponse();
            var13.volumeId = var11;
            var13.volumeIds = new String[]{var11};
            var2.getPacketHandler().write(var13);
         }
      }
   }

   class="kw">private void handleDuplicate(
      @Nonnull TriggerVolumeToolDuplicate var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         List var8 = sanitizeBatch(var1.volumeIds);
         if (!var8.isEmpty()) {
            ArrayList var9 = new ArrayList<>();
            ArrayList var10 = new ArrayList<>();
            String var11 = var4.getName().toLowerCase(Locale.ROOT);

            for (String var13 : var8) {
               VolumeEntry var14 = var7.getVolume(var13);
               if (var14 != null) {
                  String var15 = generateId(var7);
                  VolumeEntry var16 = duplicateEntry(var14, var15, var11);
                  var16.setName(var7.makeUniqueVolumeName(var14.getName(), null));
                  String var17 = var14.getGroupId();
                  if (var17 != null) {
                     GroupEntry var18 = var7.getGroup(var17);
                     if (var18 != null) {
                        var16.setGroupId(var17);
                        var18.addMember(var15);
                     }
                  }

                  var7.register(var15, var16);
                  var7.notifyViewersAdd(var16);
                  var7.enqueueVolumeCreateEvent(var16, var3, var2.getUuid());
                  var10.add(TriggerVolumeSnapshot.ofCreate(var16));
                  var9.add(var15);
               }
            }

            if (!var9.isEmpty()) {
               var7.markSpatialDirty();
               recordHistory(var5, var3, var2, var10);
               TriggerVolumeToolCreateResponse var19 = new TriggerVolumeToolCreateResponse();
               var19.volumeId = var9.getFirst();
               var19.volumeIds = var9.toArray(String[]::new);
               var2.getPacketHandler().write(var19);
            }
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static VolumeEntry duplicateEntry(@Nonnull VolumeEntry var0, @Nonnull String var1, @Nonnull String var2) {
      VolumeEntry var3 = new VolumeEntry(
         var1,
         var2,
         new Vector3d(var0.getPosition()),
         var0.getShape().copy(),
         TriggerEffect.deepCopyList(var0.getEffects()),
         EnumSet.copyOf(var0.getTargetTypes()),
         var0.isEnabled()
      );
      var3.getConditions().addAll(TriggerCondition.deepCopyList(var0.getConditions()));
      var3.getRejectionEffects().addAll(TriggerEffect.deepCopyList(var0.getRejectionEffects()));
      var3.getRules().addAll(TriggerRule.deepCopyList(var0.getRules()));
      var3.setRulesActive(var0.isRulesActive());
      var3.setConditionTiming(var0.getConditionTiming());
      var3.setRejectionDelayMode(var0.getRejectionDelayMode());
      var3.setProjectileSource(var0.getProjectileSource());
      var3.setEffectAssetRef(var0.getEffectAssetRef());
      var3.setKeepLoaded(var0.isKeepLoaded());
      var3.setActivationDelay(var0.getActivationDelay());
      var3.setCancelDelayedEffectsOnExit(var0.isCancelDelayedEffectsOnExit());
      var3.setCooldown(var0.getCooldown());
      var3.setCooldownMode(var0.getCooldownMode());
      var3.setColor(var0.getColor() != null ? new Vector3f(var0.getColor()) : null);
      if (!var0.getRawTags().isEmpty()) {
         var3.setTags(var0.getRawTags());
      }

      class="kw">return var3;
   }

   class="kw">private void handleMove(
      @Nonnull TriggerVolumeToolMove var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            Vector3d var9 = new Vector3d(var1.newPosition.x(), var1.newPosition.y(), var1.newPosition.z());
            Vector3d var10 = computeDisplayOffset(var8.getShape());
            var8.setPosition(new Vector3d(var9).sub(var10));
            var7.markSpatialDirty();
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleResize(
      @Nonnull TriggerVolumeToolResize var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            TriggerVolumeShape var9 = buildShape(
               var1.shapeType,
               var1.param1.x(),
               var1.param1.y(),
               var1.param1.z(),
               var1.param2 != null ? var1.param2.x() : 0.0F,
               var1.param2 != null ? var1.param2.y() : 0.0F,
               var1.param2 != null ? var1.param2.z() : 0.0F,
               var1.param2 != null
            );
            if (var9 == null) {
               LOGGER.at(Level.WARNING).log("Invalid shape type from %s", var2.getUuid());
            } else {
               recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
               if (var9 class="kw">instanceof BoxShape var10 && var8.getShape() class="kw">instanceof BoxShape var11 && var11.getRotation() != null) {
                  var10.setRotation(new Vector3d(var11.getRotation()));
               }

               var8.setShape(var9);
               if (var1.newPosition != null) {
                  Vector3d var13 = new Vector3d(var1.newPosition.x(), var1.newPosition.y(), var1.newPosition.z());
                  Vector3d var14 = computeDisplayOffset(var9);
                  var8.setPosition(new Vector3d(var13).sub(var14));
               }

               var7.markSpatialDirty();
               var7.notifyViewersAdd(var8);
            }
         }
      }
   }

   class="kw">private void handleRotate(
      @Nonnull TriggerVolumeToolRotate var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null && var8.getShape() class="kw">instanceof BoxShape var9) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            Vector3d var12 = new Vector3d(var1.rotation.x(), var1.rotation.y(), var1.rotation.z());
            BoxShape var11 = var9.copy();
            var11.setRotation(var12.lengthSquared() > 0.0 ? var12 : null);
            var8.setShape(var11);
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleDelete(
      @Nonnull TriggerVolumeToolDelete var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofDelete(var8));
            var7.unregister(var1.volumeId);
            var7.notifyViewersRemove(var1.volumeId);
         }
      }
   }

   class="kw">private void handleGroupCreate(
      @Nonnull TriggerVolumeToolGroupCreate var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         List var8 = sanitizeBatch(var1.volumeIds);
         if (var8.size() >= 2) {
            Vector3d var9 = new Vector3d();
            int var10 = 0;
            int var11 = 0;
            ArrayList var12 = new ArrayList<>();

            for (String var14 : var8) {
               VolumeEntry var15 = var7.getVolume(var14);
               if (var15 != null) {
                  if (var15.getGroupId() != null) {
                     var11++;
                  } else {
                     var12.add(var15);
                     var9.add(var15.getPosition());
                     var10++;
                  }
               }
            }

            if (var10 < 2) {
               TriggerVolumeToolGroupCreateResponse var21 = new TriggerVolumeToolGroupCreateResponse();
               var21.groupId = "";
               var21.success = false;
               var21.skippedCount = var11;
               var2.getPacketHandler().write(var21);
            } else {
               List var20 = new ArrayList<>();

               for (VolumeEntry var24 : var12) {
                  var20.add(TriggerVolumeSnapshot.ofMutate(var24));
               }

               var9.div(var10);
               EnumSet var23 = EnumSet.noneOf(EntityTargetType.class);

               for (VolumeEntry var16 : var12) {
                  var23.addAll(var16.getTargetTypes());
               }

               if (var23.isEmpty()) {
                  var23.add(EntityTargetType.PLAYER);
               }

               String var26 = generateGroupId(var7);
               int var27 = GROUP_COLORS[ThreadLocalRandom.current().nextInt(GROUP_COLORS.length)];
               GroupEntry var17 = new GroupEntry(var26, var4.getName().toLowerCase(Locale.ROOT), var9, new ArrayList<>(), var23, true, var27);
               var7.registerGroup(var26, var17);

               for (VolumeEntry var19 : var12) {
                  var19.setGroupId(var26);
                  var17.addMember(var19.getId());
                  var7.notifyViewersAdd(var19);
               }

               recordHistory(var5, var3, var2, var20);
               TriggerVolumeToolGroupCreateResponse var28 = new TriggerVolumeToolGroupCreateResponse();
               var28.groupId = var26;
               var28.color = var27;
               var28.success = true;
               var28.skippedCount = var11;
               var2.getPacketHandler().write(var28);
            }
         }
      }
   }

   class="kw">private void handleUngroup(
      @Nonnull TriggerVolumeToolUngroup var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         GroupEntry var8 = var7.getGroup(var1.groupId);
         if (var8 != null) {
            List var9 = new ArrayList<>();
            var9.add(TriggerVolumeGroupSnapshot.ofDelete(var8));

            for (String var11 : new ArrayList<>(var8.getMemberVolumeIds())) {
               VolumeEntry var12 = var7.getVolume(var11);
               if (var12 != null) {
                  var9.add(TriggerVolumeSnapshot.ofMutate(var12));
                  var12.clearGroupActivationState(var1.groupId);
                  var12.setGroupId(null);
                  var7.notifyViewersAdd(var12);
               }
            }

            recordHistory(var5, var3, var2, var9);
            var7.unregisterGroup(var1.groupId);
         }
      }
   }

   class="kw">private void handleGroupMove(
      @Nonnull TriggerVolumeToolGroupMove var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         GroupEntry var8 = var7.getGroup(var1.groupId);
         if (var8 != null) {
            List var9 = new ArrayList<>();

            for (String var11 : var8.getMemberVolumeIds()) {
               VolumeEntry var12 = var7.getVolume(var11);
               if (var12 != null) {
                  var9.add(TriggerVolumeSnapshot.ofMutate(var12));
               }
            }

            Vector3d var14 = new Vector3d(var1.moveDelta.x(), var1.moveDelta.y(), var1.moveDelta.z());
            var8.setOrigin(new Vector3d(var8.getOrigin()).add(var14));

            for (String var16 : var8.getMemberVolumeIds()) {
               VolumeEntry var13 = var7.getVolume(var16);
               if (var13 != null) {
                  var13.setPosition(new Vector3d(var13.getPosition()).add(var14));
                  var7.notifyViewersAdd(var13);
               }
            }

            var7.markSpatialDirty();
            recordHistory(var5, var3, var2, var9);
         }
      }
   }

   class="kw">private void handleSelect(
      @Nonnull TriggerVolumeToolSelect var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         var7.setPlayerSelection(var2.getUuid(), var1.volumeId);
      }
   }

   class="kw">private void handleMultiMove(
      @Nonnull TriggerVolumeToolMultiMove var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         List var8 = sanitizeBatch(var1.volumeIds);
         if (!var8.isEmpty()) {
            List var9 = new ArrayList<>();
            Vector3d var10 = new Vector3d(var1.moveDelta.x(), var1.moveDelta.y(), var1.moveDelta.z());

            for (String var12 : var8) {
               VolumeEntry var13 = var7.getVolume(var12);
               if (var13 != null) {
                  var9.add(TriggerVolumeSnapshot.ofMutate(var13));
                  var13.setPosition(new Vector3d(var13.getPosition()).add(var10));
                  var7.notifyViewersAdd(var13);
               }
            }

            var7.markSpatialDirty();
            recordHistory(var5, var3, var2, var9);
         }
      }
   }

   class="kw">private void handleSetColor(
      @Nonnull TriggerVolumeToolSetColor var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setColor(new Vector3f(var1.color.x(), var1.color.y(), var1.color.z()));
            if (var8.getGroupId() != null) {
               GroupEntry var9 = var7.getGroup(var8.getGroupId());
               if (var9 != null) {
                  int var10 = (int)(var1.color.x() * 255.0F) & 0xFF;
                  int var11 = (int)(var1.color.y() * 255.0F) & 0xFF;
                  int var12 = (int)(var1.color.z() * 255.0F) & 0xFF;
                  var9.setColor(var10 << 16 | var11 << 8 | var12);

                  for (String var14 : var9.getMemberVolumeIds()) {
                     VolumeEntry var15 = var7.getVolume(var14);
                     if (var15 != null) {
                        var7.notifyViewersAdd(var15);
                     }
                  }
               }
            } else {
               var7.notifyViewersAdd(var8);
            }
         }
      }
   }

   class="kw">private void handleSetName(
      @Nonnull TriggerVolumeToolSetName var1, @Nonnull PlayerRef var2, @Nonnull Ref<EntityStore> var3, @Nonnull World var4, @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setName(var7.makeUniqueVolumeName(var1.name, var1.volumeId));
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSetTargetTypes(
      @Nonnull TriggerVolumeToolSetTargetTypes var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            Set var9 = var8.getTargetTypes();
            var9.clear();
            if ((var1.targetTypes & 1) != 0) {
               var9.add(EntityTargetType.PLAYER);
            }

            if ((var1.targetTypes & 2) != 0) {
               var9.add(EntityTargetType.NPC);
            }

            if ((var1.targetTypes & 4) != 0) {
               var9.add(EntityTargetType.ITEM_DROP);
            }

            if ((var1.targetTypes & 8) != 0) {
               var9.add(EntityTargetType.PROJECTILE);
            }

            if (var9.isEmpty()) {
               var9.add(EntityTargetType.PLAYER);
            }

            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSetKeepLoaded(
      @Nonnull TriggerVolumeToolSetKeepLoaded var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setKeepLoaded(var1.keepLoaded);
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSetCooldown(
      @Nonnull TriggerVolumeToolSetCooldown var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setCooldown(Math.max(0.0F, var1.cooldown));
            int var9 = Byte.toUnsignedInt(var1.cooldownMode);
            CooldownMode var10 = var9 < CooldownMode.values().length ? CooldownMode.values()[var9] : CooldownMode.PER_ENTITY;
            var8.setCooldownMode(var10);
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSelectionToolShowTriggerVolumes(
      @Nonnull SelectionToolShowTriggerVolumes var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         UUID var8 = var2.getUuid();
         if (var1.active) {
            var7.addViewer(var8, TriggerVolumeManager.ViewSource.SELECTION_TOOL);
            var7.sendVolumeDisplay(var2);
         } else {
            var7.removeViewer(var8, TriggerVolumeManager.ViewSource.SELECTION_TOOL);
            if (!var7.isViewing(var8)) {
               var2.getPacketHandler().write(new UpdateTriggerVolumeDisplay());
            }
         }
      }
   }

   class="kw">private void handleSetCancelDelayedOnExit(
      @Nonnull TriggerVolumeToolSetCancelDelayedOnExit var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setCancelDelayedEffectsOnExit(var1.cancelDelayedOnExit);
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSetActivationDelay(
      @Nonnull TriggerVolumeToolSetActivationDelay var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setActivationDelay(Math.max(0.0F, var1.activationDelay));
            var7.notifyViewersAdd(var8);
         }
      }
   }

   class="kw">private void handleSetConditionTiming(
      @Nonnull TriggerVolumeToolSetConditionTiming var1,
      @Nonnull PlayerRef var2,
      @Nonnull Ref<EntityStore> var3,
      @Nonnull World var4,
      @Nonnull Store<EntityStore> var5
   ) {
      TriggerVolumesPlugin var6 = TriggerVolumesPlugin.get();
      TriggerVolumeManager var7 = var5.getResource(var6.getManagerResourceType());
      if (var7 != null) {
         ensureViewing(var2, var7);
         VolumeEntry var8 = var7.getVolume(var1.volumeId);
         if (var8 != null) {
            recordHistory(var5, var3, var2, TriggerVolumeSnapshot.ofMutate(var8));
            var8.setConditionTiming(
               var1.conditionTiming == TriggerVolumeConditionTiming.BeforeVolumeDelay
                  ? ConditionTiming.BEFORE_VOLUME_DELAY
                  : ConditionTiming.AFTER_VOLUME_DELAY
            );
            var7.notifyViewersAdd(var8);
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static String generateGroupId(@Nonnull TriggerVolumeManager var0) {
      String var1;
      do {
         var1 = UUID.randomUUID().toString();
      } while (var0.hasGroup(var1));

      class="kw">return var1;
   }

   @Nonnull
   class="kw">private class="kw">static Vector3d computeDisplayOffset(@Nonnull TriggerVolumeShape var0) {
      if (var0 class="kw">instanceof BoxShape var1) {
         class="kw">return new Vector3d(var1.getMin()).add(var1.getMax()).mul(0.5);
      } else if (var0 class="kw">instanceof SphereShape var2) {
         class="kw">return new Vector3d(var2.getCenter());
      } else {
         class="kw">return var0 class="kw">instanceof CylinderShape var3
            ? new Vector3d(var3.getCenter().x(), var3.getCenter().y() + var3.getHeight() * 0.5, var3.getCenter().z())
            : new Vector3d();
      }
   }

   @Nonnull
   class="kw">private class="kw">static Map<String, String> copyTags(@Nonnull Map<String, String> var0) {
      if (var0.isEmpty()) {
         class="kw">return Map.of();
      }

      HashMap var1 = new HashMap<>();

      for (Entry var3 : var0.entrySet()) {
         var1.put(var3.getKey(), var3.getValue());
      }

      class="kw">return var1;
   }

   class="kw">private class="kw">static boolean isValidExtent(double var0) {
      class="kw">return var0 > 0.0 && var0 <= 1000000.0;
   }

   @Nullable
   class="kw">static TriggerVolumeShape buildShape(
      @Nonnull TriggerVolumeShapeType var0, float var1, float var2, float var3, float var4, float var5, float var6, boolean var7
   ) {
      class="kw">return class="kw">switch (var0) {
         case Box -> !var7
            ? null
            : (
               isValidExtent(var4 - var1) && isValidExtent(var5 - var2) && isValidExtent(var6 - var3)
                  ? new BoxShape(new Vector3d(var1, var2, var3), new Vector3d(var4, var5, var6))
                  : null
            );
         case Sphere -> isValidExtent(var1) ? new SphereShape(new Vector3d(0.0, 0.0, 0.0), var1) : null;
         case Cylinder -> isValidExtent(var1) && isValidExtent(var2) ? new CylinderShape(new Vector3d(0.0, 0.0, 0.0), var1, var2) : null;
      };
   }
}