WindowVoxelSpace.java

package com.hypixel.hytale.builtin.hytalegenerator.datastructures.voxelspace;

import com.hypixel.hytale.math.vector.Vector3i;
import java.util.function.Predicate;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class WindowVoxelSpace<T> implements VoxelSpace<T> {
   @Nonnull
   private final VoxelSpace<T> wrappedVoxelSpace;
   @Nonnull
   private final VoxelCoordinate min;
   @Nonnull
   private final VoxelCoordinate max;

   public WindowVoxelSpace(@Nonnull VoxelSpace<T> voxelSpace) {
      this.wrappedVoxelSpace = voxelSpace;
      this.min = new VoxelCoordinate(voxelSpace.minX(), voxelSpace.minY(), voxelSpace.minZ());
      this.max = new VoxelCoordinate(voxelSpace.maxX(), voxelSpace.maxY(), voxelSpace.maxZ());
   }

   @Nonnull
   public WindowVoxelSpace<T> setWindow(int minX, int minY, int minZ, int maxX,  maxY,  maxZ) {
       (minX >= .wrappedVoxelSpace.minX() && minY >= .wrappedVoxelSpace.minY() && minZ >= .wrappedVoxelSpace.minZ() && maxX >= minX && maxY >= minY && maxZ >= minZ && maxX <= .wrappedVoxelSpace.maxX() && maxY <= .wrappedVoxelSpace.maxY() && maxZ <= .wrappedVoxelSpace.maxZ()) {
         .min.x = minX;
         .min.y = minY;
         .min.z = minZ;
         .max.x = maxX;
         .max.y = maxY;
         .max.z = maxZ;
          ;
      }  {
           ();
      }
   }

   
    VoxelSpace<T>  {
       .wrappedVoxelSpace;
   }

      {
       (!.isInsideSpace(x, y, z)) {
          ;
      }  {
          !.wrappedVoxelSpace.isInsideSpace(x, y, z) ?  : .wrappedVoxelSpace.set(content, x, y, z);
      }
   }

      {
       .set(content, position.x, position.y, position.z);
   }

      {
      (   .minX(); x < .maxX(); ++x) {
         (   .minY(); y < .maxY(); ++y) {
            (   .minZ(); z < .maxZ(); ++z) {
               .set(content, x, y, z);
            }
         }
      }

   }

      {
        ();
   }

    T  {
       (!.isInsideSpace(x, y, z)) {
           ();
      }  {
          .wrappedVoxelSpace.getContent(x, y, z);
      }
   }

   
    T  {
       (T).getContent(position.x, position.y, position.z);
   }

      {
       (!.isInsideSpace(x, y, z)) {
           ();
      }  {
          .wrappedVoxelSpace.replace(replacement, x, y, z, mask);
      }
   }

      {
      (   source.minX(); x < source.maxX(); ++x) {
         (   source.minY(); y < source.maxY(); ++y) {
            (   source.minZ(); z < source.maxZ(); ++z) {
               .set(source.getContent(x, y, z), x, y, z);
            }
         }
      }

   }

      {
         .min.x - .wrappedVoxelSpace.minX();
       .wrappedVoxelSpace.getOriginX() - offset;
   }

      {
         .min.y - .wrappedVoxelSpace.minY();
       .wrappedVoxelSpace.getOriginY() - offset;
   }

      {
         .min.z - .wrappedVoxelSpace.minZ();
       .wrappedVoxelSpace.getOriginZ() - offset;
   }

   
    String  {
        + .wrappedVoxelSpace.getName();
   }

      {
       x >= .minX() && x < .maxX() && y >= .minY() && y < .maxY() && z >= .minZ() && z < .maxZ();
   }

      {
       .isInsideSpace(position.x, position.y, position.z);
   }

      {
      (   .minX(); x < .maxX(); ++x) {
         (   .minY(); y < .maxY(); ++y) {
            (   .minZ(); z < .maxZ(); ++z) {
               action.accept(.getContent(x, y, z), x, y, z);
            }
         }
      }

   }

      {
       .min.x;
   }

      {
       .max.x;
   }

      {
       .min.y;
   }

      {
       .max.y;
   }

      {
       .min.z;
   }

      {
       .max.z;
   }

      {
       .max.x - .min.x;
   }

      {
       .max.y - .min.y;
   }

      {
       .max.z - .min.z;
   }

   
    String  {
         String.valueOf(.wrappedVoxelSpace);
        + var10000 +  + String.valueOf(.min) +  + String.valueOf(.max) + ;
   }
}