Add FiniteBlockRegion, fix Intersect & Complement regions

Author: Pablete1234

src/main/java/in/twizmwaz/cardinal/module/region/RegionBounds.java

@@ -72,6 +72,21 @@ public RegionBounds mirror(Vector origin, Vector normal) {
         Geometry.getMirrored(cuboid.maximum(), origin, normal)));
   }
 
+  /**
+   * Substracts other regions.
+   *
+   * @param complement Regions to substract.
+   * @return The complemented region bounds.
+   */
+  public RegionBounds complement(Collection<Region> complement) {
+    Cuboid result = Cuboid.between(this.cuboid.minimum(), this.cuboid.maximum());
+    for (Region substract : complement) {
+      // Fixme: this will cause problems, because the substracted region doesn't have the same size as its bounds.
+      result = Cuboid.complement(result, substract.getBounds().getCuboid());
+    }
+    return new RegionBounds(match, result);
+  }
+
   /**
    * Checks if region bounds are bounded (non-infinite).
    *

src/main/java/in/twizmwaz/cardinal/module/region/type/FiniteBlockRegion.java

@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2016, Kevin Phoenix
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package in.twizmwaz.cardinal.module.region.type;
+
+import in.twizmwaz.cardinal.match.Match;
+import in.twizmwaz.cardinal.module.region.AbstractRegion;
+import in.twizmwaz.cardinal.module.region.Region;
+import in.twizmwaz.cardinal.module.region.RegionBounds;
+import in.twizmwaz.cardinal.util.Geometry;
+import in.twizmwaz.cardinal.util.ListUtil;
+import in.twizmwaz.cardinal.util.MaterialPattern;
+import org.bukkit.block.Block;
+import org.bukkit.util.Cuboid;
+import org.bukkit.util.Vector;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class FiniteBlockRegion extends AbstractRegion {
+
+  private FiniteBlockRegion(RegionBounds bounds, List<Block> blocks) {
+    super(bounds);
+    super.setBlocks(blocks);
+  }
+
+  @Override
+  public Collection<Block> getBlocks() {
+    return super.getBlocks();
+  }
+
+  @Override
+  public Vector getRandomPoint() {
+    return ListUtil.getRandom((List<Block>) super.getBlocks()).getLocation();
+  }
+
+  @Override
+  public boolean isBounded() {
+    return true;
+  }
+
+  public boolean contains(Vector evaluating) {
+    evaluating = Geometry.floor(evaluating);
+    for (Block block : super.getBlocks()) {
+      if (block.getLocation().equals(evaluating)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public boolean isRandomizable() {
+    return true;
+  }
+
+  /**
+   * Creates a block finite region that matches a material.
+   * @param match The match this region belongs to.
+   * @param region The region to build the finite block region on. MUST be bounded.
+   * @param pattern The material pattern to filter blocks.
+   * @return A FiniteBlockRegion containing all regions that matched the pattern.
+   */
+  public FiniteBlockRegion getFromMaterialPattern(Match match, Region region, MaterialPattern pattern) {
+    List<Block> blocks = region.getBlocks().stream().filter(block -> pattern.contains(block.getType(), block.getData()))
+        .collect(Collectors.toList());
+    return new FiniteBlockRegion(new RegionBounds(match, getBounds(blocks)), blocks);
+  }
+
+
+  private Cuboid getBounds(List<Block> blocks) {
+    List<Vector> vectors = new ArrayList<>();
+    vectors.addAll(blocks.stream().map(Block::getLocation).collect(Collectors.toList()));
+    vectors.addAll(blocks.stream().map(block -> block.getLocation().plus(1, 1, 1)).collect(Collectors.toList()));
+    return Cuboid.enclosing(vectors.toArray(new Vector[vectors.size()]));
+  }
+
+}

src/main/java/in/twizmwaz/cardinal/module/region/type/modifications/ComplementRegion.java

@@ -48,7 +48,7 @@ public class ComplementRegion extends AbstractRegion {
    * @param complements The complements.
    */
   public ComplementRegion(Region region, List<Region> complements) {
-    super(region.getBounds());
+    super(region.getBounds().complement(complements));
     this.region = region;
     this.complements = complements;
   }

src/main/java/in/twizmwaz/cardinal/module/region/type/modifications/IntersectRegion.java

@@ -43,7 +43,7 @@ public class IntersectRegion extends AbstractRegion {
   private final Collection<Region> regions;
 
   public IntersectRegion(Match match, Collection<Region> regions) {
-    super(new RegionBounds(match, Geometry.getCuboidEnclosing(regions)));
+    super(new RegionBounds(match, Geometry.getCuboidIntersecting(regions)));
     this.regions = regions;
   }
 

src/main/java/in/twizmwaz/cardinal/module/region/type/modifications/UnionRegion.java

@@ -64,12 +64,7 @@ public boolean isRandomizable() {
 
   @Override
   public boolean isBounded() {
-    for (Region region : regions) {
-      if (!region.isBounded()) {
-        return false;
-      }
-    }
-    return true;
+    return getBounds().isBounded();
   }
 
   @Override

src/main/java/in/twizmwaz/cardinal/util/Geometry.java

@@ -31,6 +31,9 @@
 import org.bukkit.util.Vector;
 
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 public class Geometry {
@@ -93,6 +96,16 @@ public static Vector getMinimum(@NonNull Vector... vectors) {
     return Cuboid.enclosing(vectors).minimum();
   }
 
+  /**
+   * Gets the second minimum double from a list of doubles.
+   *
+   * @param doubles The list of doubles.
+   * @return The second minimum double.
+   */
+  public static double getSecondMinimum(@NonNull List<Double> doubles) {
+    return doubles.stream().sorted().collect(Collectors.toList()).get(1);
+  }
+
   /**
    * Gets the maximum vector from a list of regions.
    *
@@ -151,4 +164,28 @@ public static Cuboid getCuboidEnclosing(Collection<Region> regions) {
     return Cuboid.between(getMinimumBound(regions), getMaximumBound(regions));
   }
 
+  public static Cuboid getCuboidIntersecting(Collection<Region> regions) {
+    if (regions.size() < 2) {
+      return Cuboid.empty();
+    }
+    List<Vector>
+        mins = regions.stream().map(region -> region.getBounds().getCuboid().minimum()).collect(Collectors.toList()),
+        maxs = regions.stream().map(region -> region.getBounds().getCuboid().maximum()).collect(Collectors.toList());
+    return Cuboid.between(
+        new Vector(
+            getSecond(mins, Vector::getX, false),
+            getSecond(mins, Vector::getY, false),
+            getSecond(mins, Vector::getZ, false)),
+        new Vector(
+            getSecond(maxs, Vector::getX, true),
+            getSecond(maxs, Vector::getY, true),
+            getSecond(maxs, Vector::getZ, true)));
+  }
+
+
+  private static double getSecond(@NonNull List<Vector> vectors, Function<Vector, Double> function, boolean max) {
+    return vectors.stream().map(function)
+        .sorted(max ? Comparator.reverseOrder() : Comparator.naturalOrder()).collect(Collectors.toList()).get(1);
+  }
+
 }