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

class="kw">import com.hypixel.hytale.builtin.buildertools.BuilderToolsPlugin;
class="kw">import com.hypixel.hytale.builtin.buildertools.EditOperation;
class="kw">import com.hypixel.hytale.builtin.buildertools.PrototypePlayerBuilderToolSettings;
class="kw">import com.hypixel.hytale.builtin.buildertools.tooloperations.transform.Mirror;
class="kw">import com.hypixel.hytale.builtin.buildertools.tooloperations.transform.Rotate;
class="kw">import com.hypixel.hytale.builtin.buildertools.tooloperations.transform.Transform;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.function.predicate.TriIntObjPredicate;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.block.BlockConeUtil;
class="kw">import com.hypixel.hytale.math.block.BlockCubeUtil;
class="kw">import com.hypixel.hytale.math.block.BlockCylinderUtil;
class="kw">import com.hypixel.hytale.math.block.BlockDiamondUtil;
class="kw">import com.hypixel.hytale.math.block.BlockDomeUtil;
class="kw">import com.hypixel.hytale.math.block.BlockInvertedDomeUtil;
class="kw">import com.hypixel.hytale.math.block.BlockPyramidUtil;
class="kw">import com.hypixel.hytale.math.block.BlockSphereUtil;
class="kw">import com.hypixel.hytale.math.block.BlockTorusUtil;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.Rotation;
class="kw">import com.hypixel.hytale.protocol.packets.buildertools.BrushAxis;
class="kw">import com.hypixel.hytale.protocol.packets.buildertools.BrushOrigin;
class="kw">import com.hypixel.hytale.protocol.packets.buildertools.BrushShape;
class="kw">import com.hypixel.hytale.protocol.packets.buildertools.BuilderToolOnUseInteraction;
class="kw">import com.hypixel.hytale.server.core.asset.type.buildertool.config.BuilderTool;
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.inventory.InventoryComponent;
class="kw">import com.hypixel.hytale.server.core.inventory.ItemStack;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HeadRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockFilter;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockMask;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.standard.BlockSelection;
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 com.hypixel.hytale.server.core.util.TargetUtil;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Random;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.logging.Level;
class="kw">import java.util.regex.Pattern;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class="kw">abstract class ToolOperation class="kw">implements TriIntObjPredicate<Void> {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">protected class="kw">static class="kw">final int RANDOM_MAX = 100;
   @Nonnull
   class="kw">public class="kw">static class="kw">final Map<String, OperationFactory> OPERATIONS = new ConcurrentHashMap<>();
   @Nonnull
   class="kw">public class="kw">static class="kw">final Map<UUID, PrototypePlayerBuilderToolSettings> PROTOTYPE_TOOL_SETTINGS = new ConcurrentHashMap<>();
   class="kw">public class="kw">static class="kw">final double MAX_DISTANCE = 400.0;
   class="kw">public class="kw">static class="kw">final int DEFAULT_BRUSH_SPACING = 0;
   class="kw">private class="kw">static class="kw">final Pattern NEWLINES_PATTERN = Pattern.compile("\\r?\\n");
   class="kw">protected class="kw">final int x;
   class="kw">protected class="kw">final int y;
   class="kw">protected class="kw">final int z;
   class="kw">protected class="kw">final InteractionType interactionType;
   class="kw">protected class="kw">final int shapeRange;
   class="kw">protected class="kw">final int shapeHeight;
   class="kw">protected class="kw">final int shapeThickness;
   class="kw">protected class="kw">final boolean capped;
   class="kw">protected class="kw">final int originOffsetX;
   class="kw">protected class="kw">final int originOffsetY;
   class="kw">protected class="kw">final int originOffsetZ;
   class="kw">protected class="kw">final BrushShape shape;
   class="kw">protected class="kw">final BlockPattern pattern;
   class="kw">protected class="kw">final int density;
   class="kw">protected class="kw">final int spacing;
   @Nonnull
   class="kw">protected class="kw">final EditOperation edit;
   @Nonnull
   class="kw">protected class="kw">final BuilderTool.ArgData args;
   @Nonnull
   class="kw">protected class="kw">final Random random;
   @Nonnull
   class="kw">protected class="kw">final Player player;
   @Nonnull
   class="kw">protected class="kw">final PlayerRef playerRef;
   @Nonnull
   class="kw">protected class="kw">final Ref<EntityStore> playerEntityRef;
   @Nonnull
   class="kw">protected class="kw">final BuilderToolsPlugin.BuilderState builderState;
   class="kw">private Transform transform;
   class="kw">private class="kw">final Vector3i vector = new Vector3i();
   class="kw">protected int currentCenterX;
   class="kw">protected int currentCenterY;
   class="kw">protected int currentCenterZ;
   @Nullable
   class="kw">private class="kw">final BlockMask mask;

   class="kw">public ToolOperation(@Nonnull Ref<EntityStore> var1, @Nonnull BuilderToolOnUseInteraction var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      this.playerEntityRef = var1;
      World var4 = var3.getExternalData().getWorld();
      Player var5 = var3.getComponent(var1, Player.getComponentType());
      assert var5 != null;
      PlayerRef var6 = var3.getComponent(var1, PlayerRef.getComponentType());
      assert var6 != null;
      this.player = var5;
      this.playerRef = var6;
      this.builderState = BuilderToolsPlugin.getState(var5, var6);
      UUIDComponent var7 = var3.getComponent(var1, UUIDComponent.getComponentType());
      assert var7 != null;
      UUID var8 = var7.getUuid();
      PrototypePlayerBuilderToolSettings var9 = PROTOTYPE_TOOL_SETTINGS.get(var8);
      if (var9 == null) {
         var9 = new PrototypePlayerBuilderToolSettings(var8);
         PROTOTYPE_TOOL_SETTINGS.put(var8, var9);
      }

      var9.setMaxLengthOfIgnoredPaintOperations(var2.maxLengthToolIgnoreHistory);
      if (!var2.isHoldDownInteraction && (this class="kw">instanceof PaintOperation || this class="kw">instanceof SculptOperation)) {
         var9.getIgnoredPaintOperations().clear();
         var9.clearLastBrushPosition();
      }

      BuilderTool var10 = BuilderTool.getActiveBuilderTool(var1, var3);
      ItemStack var11 = InventoryComponent.getItemInHand(var3, var1);
      BuilderTool.ArgData var12 = this.args = var10.getItemArgData(var11);
      Object var13 = var12.tool().get("builtin_Width");
      Object var14 = var12.tool().get("builtin_Height");
      Object var15 = var12.tool().get("builtin_Thickness");
      Object var16 = var12.tool().get("builtin_Capped");
      Object var17 = var12.tool().get("builtin_Shape");
      Object var18 = var12.tool().get("builtin_Density");
      Object var19 = var12.tool().get("builtin_Spacing");
      Object var20 = var12.tool().get("builtin_Material");
      int var21 = var13 != null ? (Integer)var13 : 5;
      int var22 = var14 != null ? (Integer)var14 : 5;
      boolean var23 = var21 % 2 == 0;
      boolean var24 = var22 % 2 == 0;
      int[] var26 = getRotatedEvenSnapAxes(var12.tool().get("builtin_RotationFace") class="kw">instanceof String var27 ? var27 : "Up", var23, var24);
      if (var2.isDoServerRaytraceForPosition && (this class="kw">instanceof PaintOperation || this class="kw">instanceof SculptOperation)) {
         Vector3d var40 = new Vector3d();
         Vector3i var28 = this.getTargetBlockAvoidingPaint(
            var1,
            400.0,
            var3,
            var2.raycastOriginX,
            var2.raycastOriginY,
            var2.raycastOriginZ,
            var2.raycastDirectionX,
            var2.raycastDirectionY,
            var2.raycastDirectionZ,
            var40
         );
         if (var28 != null) {
            int var29 = var28.x + var2.offsetForPaintModeX;
            int var30 = var28.y + var2.offsetForPaintModeY;
            int var31 = var28.z + var2.offsetForPaintModeZ;
            if (var26[0] > 0 && var40.x - var28.x >= 0.5) {
               var29++;
            } else if (var26[0] < 0 && var40.x - var28.x < 0.5) {
               var29--;
            }

            if (var26[1] > 0 && var40.y - var28.y >= 0.5) {
               var30++;
            } else if (var26[1] < 0 && var40.y - var28.y < 0.5) {
               var30--;
            }

            if (var26[2] > 0 && var40.z - var28.z >= 0.5) {
               var31++;
            } else if (var26[2] < 0 && var40.z - var28.z < 0.5) {
               var31--;
            }

            this.x = var29;
            this.y = var30;
            this.z = var31;
         } else {
            this.x = var2.x;
            this.y = var2.y;
            this.z = var2.z;
         }
      } else {
         this.x = var2.x;
         this.y = var2.y;
         this.z = var2.z;
      }

      this.interactionType = var2.type;
      this.transform = getTransform(var1, var12, this.vector, var3);
      this.shapeRange = var21;
      this.shapeHeight = var22;
      this.shapeThickness = var15 != null ? (Integer)var15 : 0;
      this.capped = var16 != null ? (Boolean)var16 : false;
      this.shape = var17 != null ? BrushShape.valueOf((String)var17) : BrushShape.Sphere;
      this.density = var18 != null ? (Integer)var18 : 100;
      this.spacing = var19 != null ? (Integer)var19 : 0;
      this.pattern = var20 != null ? (BlockPattern)var20 : BlockPattern.EMPTY;
      this.mask = combineMasks(var12, this.builderState.getGlobalMask());
      Object var41 = var12.tool().get("builtin_Origin");
      Object var42 = var12.tool().get("builtin_OriginRotation");
      BrushOrigin var43 = var41 != null ? BrushOrigin.valueOf((String)var41) : BrushOrigin.Center;
      boolean var44 = var42 != null ? (Boolean)var42 : false;
      int var45 = this.shapeRange;
      int var32 = this.shapeHeight;
      if (this.shape == BrushShape.Torus) {
         int var33 = this.shapeRange / 2;
         int var34 = Math.max(1, this.shapeHeight / 4);
         int var35 = Math.max(1, var33 - var34);
         int var36 = var35 + var34;
         var45 = this.shapeRange % 2 == 0 ? var36 * 2 : var36 * 2 + 1;
         var32 = this.shapeHeight % 2 == 0 ? var34 * 2 : var34 * 2 + 1;
      }

      Transform var46 = this.getBrushRotation(var3);
      Vector3i var47 = getOffsets(var45, var32, var44, var43, this.transform, var46, this.vector);
      this.originOffsetX = var47.x();
      this.originOffsetY = var47.y();
      this.originOffsetZ = var47.z();
      this.random = this.builderState.getRandom();
      this.currentCenterX = this.x;
      this.currentCenterY = this.y;
      this.currentCenterZ = this.z;
      Vector3i var48 = new Vector3i(this.x - this.shapeRange, this.y - this.shapeHeight, this.z - this.shapeRange);
      Vector3i var49 = new Vector3i(this.x + this.shapeRange, this.y + this.shapeHeight, this.z + this.shapeRange);
      BlockSelection var37 = BuilderToolsPlugin.getMaskSelection(this.builderState.getSelection());
      Vector3i var38 = var37 == null ? null : var37.getSelectionMin();
      Vector3i var39 = var37 == null ? null : var37.getSelectionMax();
      this.edit = new EditOperation(var4, this.x, this.y, this.z, this.shapeRange, var48, var49, var38, var39, this.mask);
   }

   @Nonnull
   class="kw">public class="kw">static PrototypePlayerBuilderToolSettings getOrCreatePrototypeSettings(UUID var0) {
      PrototypePlayerBuilderToolSettings var1 = PROTOTYPE_TOOL_SETTINGS.get(var0);
      if (var1 == null) {
         var1 = new PrototypePlayerBuilderToolSettings(var0);
         PROTOTYPE_TOOL_SETTINGS.put(var0, var1);
      }

      class="kw">return var1;
   }

   @Nonnull
   class="kw">public class="kw">static List<Vector3i> calculateInterpolatedPositions(@Nullable Vector3i var0, @Nonnull Vector3i var1, int var2, int var3, int var4) {
      ArrayList var5 = new ArrayList<>();
      if (var0 == null) {
         var5.add(var1);
         class="kw">return var5;
      }

      double var6 = var1.x() - var0.x();
      double var8 = var1.y() - var0.y();
      double var10 = var1.z() - var0.z();
      double var12 = Math.sqrt(var6 * var6 + var8 * var8 + var10 * var10);
      if (var4 == 0) {
         float var14 = Math.max(var2, var3);
         float var15 = Math.max(1.0F, var14 * 0.5F);
         if (var12 <= var15) {
            var5.add(var1);
            class="kw">return var5;
         }

         int var16 = (int)Math.ceil(var12 / var15);

         for (int var17 = 1; var17 <= var16; var17++) {
            float var18 = (float)var17 / var16;
            int var19 = (int)Math.round(var0.x() + var6 * var18);
            int var20 = (int)Math.round(var0.y() + var8 * var18);
            int var21 = (int)Math.round(var0.z() + var10 * var18);
            var5.add(new Vector3i(var19, var20, var21));
         }
      } else if (var12 >= var4) {
         var5.add(var1);
      }

      class="kw">return var5;
   }

   @Nonnull
   class="kw">public Vector3i getPosition() {
      class="kw">return new Vector3i(this.x, this.y, this.z);
   }

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

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

   class="kw">public int getBrushSpacing() {
      Object var1 = this.args.tool().get("builtin_BrushSpacing");
      class="kw">return var1 class="kw">instanceof Number ? ((Number)var1).intValue() : 0;
   }

   class="kw">public Transform getBrushRotation(ComponentAccessor<EntityStore> var1) {
      Object var2 = this.args.tool().get("builtin_RotationFace");
      Transform var3 = Transform.NONE;
      if (var2 class="kw">instanceof String var4) {
         if (var4.equalsIgnoreCase("down")) {
            var3 = Rotate.forAxisAndAngle(BrushAxis.X, Rotation.OneEighty);
         } else if (var4.equalsIgnoreCase("north")) {
            var3 = Rotate.forAxisAndAngle(BrushAxis.X, Rotation.TwoSeventy);
         } else if (var4.equalsIgnoreCase("south")) {
            var3 = Rotate.forAxisAndAngle(BrushAxis.X, Rotation.Ninety);
         } else if (var4.equalsIgnoreCase("east")) {
            var3 = Rotate.forAxisAndAngle(BrushAxis.Z, Rotation.TwoSeventy);
         } else if (var4.equalsIgnoreCase("west")) {
            var3 = Rotate.forAxisAndAngle(BrushAxis.Z, Rotation.Ninety);
         } else if (var4.equalsIgnoreCase("camera")) {
            HeadRotation var5 = var1.getComponent(this.playerEntityRef, HeadRotation.getComponentType());
            assert var5 != null;
            var3 = Rotate.forDirection(var5.getAxisDirection(), Rotation.None);
         }
      }

      class="kw">return var3;
   }

   class="kw">public void executeAsBrushConfig(
      @Nonnull PrototypePlayerBuilderToolSettings var1, @Nonnull BuilderToolOnUseInteraction var2, ComponentAccessor<EntityStore> var3
   ) {
      World var4 = var3.getExternalData().getWorld();
      var1.setUndoGroupSize(var2.undoGroupSize);
      var1.getBrushConfigCommandExecutor()
         .execute(this.playerEntityRef, var4, new Vector3i(this.x, this.y, this.z), var2.isHoldDownInteraction, var2.type, var2x -> {
            var2x.setPattern(this.pattern);
            var2x.setDensity(this.density);
            var2x.setShapeHeight(this.shapeHeight);
            var2x.setShapeWidth(this.shapeRange);
            var2x.setShape(this.shape);
            var2x.setCapped(this.capped);
            var2x.setTransform(this.getBrushRotation(var3));
            var2x.setTransformOrigin(new Vector3i(this.x, this.y, this.z));
            var2x.modifyOriginOffset(new Vector3i(this.originOffsetX, this.originOffsetY, this.originOffsetZ));
            var2x.setBrushMask(this.mask);
            var2x.setShapeThickness(this.shapeThickness);
         }, var3);
   }

   @Nullable
   class="kw">public Vector3i getTargetBlockAvoidingPaint(
      @Nonnull Ref<EntityStore> var1,
      double var2,
      @Nonnull ComponentAccessor<EntityStore> var4,
      float var5,
      float var6,
      float var7,
      float var8,
      float var9,
      float var10
   ) {
      class="kw">return this.getTargetBlockAvoidingPaint(var1, var2, var4, var5, var6, var7, var8, var9, var10, null);
   }

   @Nullable
   class="kw">public Vector3i getTargetBlockAvoidingPaint(
      @Nonnull Ref<EntityStore> var1,
      double var2,
      @Nonnull ComponentAccessor<EntityStore> var4,
      float var5,
      float var6,
      float var7,
      float var8,
      float var9,
      float var10,
      @Nullable Vector3d var11
   ) {
      World var12 = var4.getExternalData().getWorld();
      UUIDComponent var13 = var4.getComponent(var1, UUIDComponent.getComponentType());
      assert var13 != null;
      PrototypePlayerBuilderToolSettings var14 = PROTOTYPE_TOOL_SETTINGS.get(var13.getUuid());
      if (var14 == null || var14.getIgnoredPaintOperations().isEmpty()) {
         Vector3i var15 = TargetUtil.getTargetBlock(var12, (var0, var1x) -> var0 != 0, var5, var6, var7, var8, var9, var10, var2);
         if (var15 == null) {
            class="kw">return null;
         }

         if (var11 != null) {
            Vector3d var16 = TargetUtil.getTargetLocation(var12, var0 -> var0 != 0, var5, var6, var7, var8, var9, var10, var2);
            if (var16 != null) {
               var11.x = var16.x;
               var11.y = var16.y;
               var11.z = var16.z;
            }
         }

         class="kw">return var15;
      } else {
         class="kw">return var11 != null
            ? TargetUtil.getTargetBlockAvoidLocations(
               var12, var0 -> var0 != 0, var5, var6, var7, var8, var9, var10, var2, var14.getIgnoredPaintOperations(), var11
            )
            : TargetUtil.getTargetBlockAvoidLocations(var12, var0 -> var0 != 0, var5, var6, var7, var8, var9, var10, var2, var14.getIgnoredPaintOperations());
      }
   }

   @Nonnull
   class="kw">public EditOperation getEditOperation() {
      class="kw">return this.edit;
   }

   class="kw">public class="kw">final boolean test(int var1, int var2, int var3, Void var4) {
      if (this.transform == Transform.NONE) {
         class="kw">return this.executeBlock(var1 + this.originOffsetX, var2 + this.originOffsetY, var3 + this.originOffsetZ);
      }

      this.vector.set(var1 - this.currentCenterX, var2 - this.currentCenterY, var3 - this.currentCenterZ);
      this.transform.apply(this.vector);
      var1 = this.currentCenterX + this.originOffsetX + this.vector.x;
      var2 = this.currentCenterY + this.originOffsetY + this.vector.y;
      var3 = this.currentCenterZ + this.originOffsetZ + this.vector.z;
      class="kw">return this.executeBlock(var1, var2, var3);
   }

   class="kw">public boolean showEditNotification() {
      class="kw">return true;
   }

   class="kw">protected class="kw">abstract boolean executeBlock(int var1, int var2, int var3);

   class="kw">public void execute(ComponentAccessor<EntityStore> var1) {
      executeShapeOperation(this.x, this.y, this.z, this, this.shape, this.shapeRange, this.shapeHeight, this.shapeThickness, this.capped);
   }

   class="kw">public void executeAt(int var1, int var2, int var3, ComponentAccessor<EntityStore> var4) {
      this.currentCenterX = var1;
      this.currentCenterY = var2;
      this.currentCenterZ = var3;
      executeShapeOperation(var1, var2, var3, this, this.shape, this.shapeRange, this.shapeHeight, this.shapeThickness, this.capped);
   }

   class="kw">public class="kw">static void executeShapeOperation(
      int var0, int var1, int var2, @Nonnull TriIntObjPredicate<Void> var3, @Nonnull BrushShape var4, int var5, int var6, int var7, boolean var8
   ) {
      if (var5 <= 1 && var6 <= 1 && var4 != BrushShape.Torus) {
         var3.test(var0, var1, var2, null);
      } else {
         int var9 = var5 / 2;
         int var10 = var6 / 2;
         boolean var11 = var5 % 2 == 0;
         boolean var12 = var6 % 2 == 0;
         if (var9 < 1 && var4 != BrushShape.Torus) {
            BlockCubeUtil.forEachBlock(var0, var1, var2, 0, var6, 0, false, var12, null, var3);
            class="kw">return;
         }

         class="kw">switch (var4) {
            case Cube:
            class="kw">default:
               BlockCubeUtil.forEachBlock(var0, var1, var2, var9, var6, var9, var7, var8, var8, false, var11, var12, null, var3);
               break;
            case Sphere:
               if (var10 < 1) {
                  BlockCylinderUtil.forEachBlock(var0, var1, var2, var9, var6, var9, var7, var8, var11, false, null, var3);
               } else {
                  BlockSphereUtil.forEachBlock(var0, var1, var2, var9, var10, var9, var7, var11, var12, null, var3);
               }
               break;
            case Cylinder:
               BlockCylinderUtil.forEachBlock(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case Cone:
               BlockConeUtil.forEachBlock(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case InvertedCone:
               BlockConeUtil.forEachBlockInverted(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case Pyramid:
               BlockPyramidUtil.forEachBlock(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case InvertedPyramid:
               BlockPyramidUtil.forEachBlockInverted(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case Dome:
               BlockDomeUtil.forEachBlock(var0, var1 - var10, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case InvertedDome:
               BlockInvertedDomeUtil.forEachBlock(var0, var1 + (var6 - 1) / 2, var2, var9, var6, var9, var7, var8, var11, var12, null, var3);
               break;
            case Diamond:
               BlockDiamondUtil.forEachBlock(var0, var1, var2, var9, var6 / 2, var9, var7, var8, var11, var12, null, var3);
               break;
            case Torus:
               int var13 = Math.max(1, var6 / 4);
               int var14 = Math.max(1, var9);
               BlockTorusUtil.forEachBlock(var0, var1, var2, var14, var13, var7, var8, var11, var12, null, var3);
         }
      }
   }

   @Nonnull
   class="kw">private class="kw">static Vector3i getOffsets(
      int var0, int var1, boolean var2, BrushOrigin var3, @Nonnull Transform var4, @Nonnull Transform var5, @Nonnull Vector3i var6
   ) {
      int var7 = var1 / 2;
      int var8 = var2 ? var0 / 2 : 0;
      if (var3 != BrushOrigin.Lowest && var3 != BrushOrigin.Highest) {
         var6.set(0, var7, 0);
         var4.apply(var6);
         int var16 = var6.x();
         int var18 = var6.z();
         var6.set(var8, var7, -var8);
         var4.apply(var6);
         int var20 = var6.y();
         var16 = var3 == BrushOrigin.Center ? 0 : (var3 == BrushOrigin.Bottom ? var16 : -var16);
         var20 = var3 == BrushOrigin.Center ? 0 : (var3 == BrushOrigin.Bottom ? var20 : -var20);
         var18 = var3 == BrushOrigin.Center ? 0 : (var3 == BrushOrigin.Bottom ? var18 : -var18);
         class="kw">return var6.set(var16, var20, var18);
      }

      int var9 = var0 / 2;
      int var10 = (var0 - 1) / 2;
      int var11 = Integer.MAX_VALUE;
      int var12 = Integer.MIN_VALUE;

      for (int var13 = -1; var13 <= 1; var13 += 2) {
         for (int var14 = -1; var14 <= 1; var14 += 2) {
            for (int var15 = -1; var15 <= 1; var15 += 2) {
               var6.set(var13 < 0 ? -var9 : var10, var14 < 0 ? -var7 : var7, var15 < 0 ? -var9 : var10);
               var5.apply(var6);
               var11 = Math.min(var11, var6.y());
               var12 = Math.max(var12, var6.y());
            }
         }
      }

      int var22 = var3 == BrushOrigin.Lowest ? -var11 : -var12;
      var6.set(0, var22, 0);
      if (var5 class="kw">instanceof Rotate var23) {
         var23.inverse().apply(var6);
      }

      class="kw">return var6;
   }

   class="kw">private class="kw">static int[] getRotatedEvenSnapAxes(String var0, boolean var1, boolean var2) {
      int[] var3 = new int[]{1, 0, 0};
      int[] var4 = new int[]{0, 1, 0};
      int[] var5 = new int[]{0, 0, 1};
      int var6;
      int var7;
      class="kw">switch (var0.toLowerCase(Locale.ROOT)) {
         case "down":
            var7 = 0;
            var6 = 2;
            break;
         case "north":
            var7 = 0;
            var6 = 3;
            break;
         case "south":
            var7 = 0;
            var6 = 1;
            break;
         case "east":
            var7 = 2;
            var6 = 3;
            break;
         case "west":
            var7 = 2;
            var6 = 1;
            break;
         class="kw">default:
            var7 = 0;
            var6 = 0;
      }

      for (int var10 = 0; var10 < var6; var10++) {
         rotate90(var3, var7);
         rotate90(var4, var7);
         rotate90(var5, var7);
      }

      class="kw">return new int[]{
         evenSnapSign(var1, var3[0], var5[0], var2, var4[0]),
         evenSnapSign(var1, var3[1], var5[1], var2, var4[1]),
         evenSnapSign(var1, var3[2], var5[2], var2, var4[2])
      };
   }

   class="kw">private class="kw">static void rotate90(int[] var0, int var1) {
      class="kw">switch (var1) {
         case 0: {
            int var4 = var0[1];
            var0[1] = -var0[2];
            var0[2] = var4;
            break;
         }
         case 1: {
            int var3 = var0[0];
            var0[0] = var0[2];
            var0[2] = -var3;
            break;
         }
         case 2: {
            int var2 = var0[0];
            var0[0] = -var0[1];
            var0[1] = var2;
         }
      }
   }

   class="kw">private class="kw">static int evenSnapSign(boolean var0, int var1, int var2, boolean var3, int var4) {
      if (var0 && var1 != 0) {
         class="kw">return var1;
      } else if (var0 && var2 != 0) {
         class="kw">return var2;
      } else {
         class="kw">return var3 && var4 != 0 ? var4 : 0;
      }
   }

   class="kw">private class="kw">static Transform getTransform(
      @Nonnull Ref<EntityStore> var0, @Nonnull BuilderTool.ArgData var1, @Nonnull Vector3i var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      Transform var4 = getRotation(var0, var1, var2, var3);
      Transform var5 = getMirror(var0, var1, var2, var3);
      class="kw">return var4.then(var5);
   }

   class="kw">private class="kw">static Transform getRotation(
      @Nonnull Ref<EntityStore> var0, @Nonnull BuilderTool.ArgData var1, @Nonnull Vector3i var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      Object var4 = var1.tool().get("builtin_RotationAxis");
      Object var5 = var1.tool().get("builtin_RotationAngle");
      BrushAxis var6 = var4 != null ? BrushAxis.valueOf((String)var4) : BrushAxis.None;
      Rotation var7 = var5 != null ? Rotation.valueOf((String)var5) : Rotation.None;
      if (var6 == BrushAxis.Auto) {
         HeadRotation var8 = var3.getComponent(var0, HeadRotation.getComponentType());
         assert var8 != null;
         class="kw">return Rotate.forDirection(var8.getAxisDirection(var2), var7);
      } else {
         class="kw">return Rotate.forAxisAndAngle(var6, var7);
      }
   }

   class="kw">private class="kw">static Transform getMirror(
      @Nonnull Ref<EntityStore> var0, @Nonnull BuilderTool.ArgData var1, @Nonnull Vector3i var2, @Nonnull ComponentAccessor<EntityStore> var3
   ) {
      Object var4 = var1.tool().get("builtin_MirrorAxis");
      BrushAxis var5 = var4 != null ? BrushAxis.valueOf((String)var4) : BrushAxis.None;
      if (var5 == BrushAxis.Auto) {
         HeadRotation var6 = var3.getComponent(var0, HeadRotation.getComponentType());
         assert var6 != null;
         class="kw">return Mirror.forDirection(var6.getAxisDirection(var2), false);
      } else {
         class="kw">return Mirror.forAxis(var5);
      }
   }

   @Nonnull
   class="kw">public class="kw">static ToolOperation fromPacket(
      @Nonnull Ref<EntityStore> var0,
      @Nonnull Player var1,
      @Nonnull PlayerRef var2,
      @Nonnull BuilderToolOnUseInteraction var3,
      @Nonnull ComponentAccessor<EntityStore> var4
   ) class="kw">throws Exception {
      BuilderTool var5 = BuilderTool.getActiveBuilderTool(var0, var4);
      if (var5 == null) {
         throw new IllegalStateException("No builder tool active on player");
      } else {
         String var6 = var5.getId();
         OperationFactory var7 = OPERATIONS.get(var6);
         if (var7 == null) {
            throw new Exception("No tool found matching id " + var6);
         } else {
            class="kw">return var7.create(var0, var1, var2, var3, var4);
         }
      }
   }

   @Nullable
   class="kw">public class="kw">static BlockMask combineMasks(@Nullable BuilderTool.ArgData var0, @Nullable BlockMask var1) {
      if (var0 == null) {
         class="kw">return var1;
      } else {
         Object var2 = var0.tool().get("builtin_InvertMask");
         boolean var3 = var2 != null ? (Boolean)var2 : false;
         if (var0.tool().get("builtin_MaskEntries") class="kw">instanceof String var5 && !var5.isEmpty()) {
            class="kw">return parseMaskEntries(var5, var1);
         } else {
            Object var18 = var0.tool().get("builtin_Mask");
            Object var6 = var0.tool().get("builtin_MaskAbove");
            Object var7 = var0.tool().get("builtin_MaskNot");
            Object var8 = var0.tool().get("builtin_MaskBelow");
            Object var9 = var0.tool().get("builtin_MaskAdjacent");
            Object var10 = var0.tool().get("builtin_MaskNeighbor");
            BlockMask var11 = BlockMask.EMPTY;
            BlockMask var12 = BlockMask.EMPTY;
            BlockMask var13 = BlockMask.EMPTY;
            BlockMask var14 = BlockMask.EMPTY;
            BlockMask var15 = BlockMask.EMPTY;
            BlockMask var16 = BlockMask.EMPTY;
            if (var18 != null) {
               var11 = (BlockMask)var18;
            }

            if (var6 != null) {
               var12 = (BlockMask)var6;
               var12 = var12.withOptions(BlockFilter.FilterType.AboveBlock, false);
            }

            if (var7 != null) {
               var13 = (BlockMask)var7;
               var13 = var13.withOptions(BlockFilter.FilterType.TargetBlock, true);
            }

            if (var8 != null) {
               var14 = (BlockMask)var8;
               var14 = var14.withOptions(BlockFilter.FilterType.BelowBlock, false);
            }

            if (var9 != null) {
               var15 = (BlockMask)var9;
               var15 = var15.withOptions(BlockFilter.FilterType.AdjacentBlock, false);
            }

            if (var10 != null) {
               var16 = (BlockMask)var10;
               var16 = var16.withOptions(BlockFilter.FilterType.NeighborBlock, false);
            }

            BlockMask var17 = BlockMask.combine(var11, var12, var13, var14, var15, var16, var1);
            if (var17 != null) {
               var17.setInverted(var3);
            }

            class="kw">return var17;
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static BlockMask parseMaskEntries(@Nonnull String var0, @Nullable BlockMask var1) {
      try {
         String var2 = var0.replace("{", "").replace("}", "");
         BlockMask var3 = BlockMask.parse(var2);
         if (var3 != null && var3 != BlockMask.EMPTY) {
            class="kw">return var1 != null ? BlockMask.combine(var3, var1) : var3;
         } else {
            class="kw">return var1;
         }
      } catch (Exception var4) {
         ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var4)).log("Failed to parse mask entries: %s", var0);
         class="kw">return var1;
      }
   }

   class="kw">static {
      OPERATIONS.put("Noise", NoiseOperation::new);
      OPERATIONS.put("Scatter", ScatterOperation::new);
      OPERATIONS.put("Smooth", (var0, var1, var2, var3, var4) -> new SmoothOperation(var0, var3, var4));
      OPERATIONS.put("Tint", TintOperation::new);
      OPERATIONS.put("Paint", PaintOperation::new);
      OPERATIONS.put("OldSculpt", OldSculptOperation::new);
      OPERATIONS.put("Sculpt", SculptOperation::new);
      OPERATIONS.put("Layers", LayersOperation::new);
      OPERATIONS.put("LaserPointer", LaserPointerOperation::new);
      OPERATIONS.put("Revolve", RevolveOperation::new);
      OPERATIONS.put("ScriptedBrushTemplate", PaintOperation::new);
   }
}