Refactor math classes + other changes

main/src/jmh/java/org/minerift/ether/benchmark/PermissionSetBenchmarks.java

@@ -36,19 +36,19 @@ public static void main(String[] args) throws RunnerException {
 
     @State(Scope.Benchmark)
     public static class BenchmarkState {
-        PermissionSet set;
+        PermissionSet permissions;
 
         @Setup
         public void setup() {
-            this.set = new PermissionSet();
-            set.setPermissions(IslandRole.OWNER, EnumSet.allOf(IslandPermission.class));
-            set.setPermissions(IslandRole.MEMBER, EnumSet.range(IslandPermission.BLOCK_BREAK, IslandPermission.ENTITY_INTERACT));
-            set.setPermissions(IslandRole.VISITOR, EnumSet.noneOf(IslandPermission.class));
+            this.permissions = new PermissionSet();
+            permissions.set(IslandRole.OWNER, EnumSet.allOf(IslandPermission.class));
+            permissions.set(IslandRole.MEMBER, EnumSet.range(IslandPermission.BLOCK_BREAK, IslandPermission.ENTITY_INTERACT));
+            permissions.set(IslandRole.VISITOR, EnumSet.noneOf(IslandPermission.class));
         }
     }
 
     @Benchmark
     public boolean hasPermissionBenchmark(BenchmarkState state) {
-        return state.set.hasPermission(IslandRole.MEMBER, IslandPermission.ENTITY_DAMAGE); // not included in range; expect false
+        return state.permissions.has(IslandRole.MEMBER, IslandPermission.ENTITY_DAMAGE); // not included in range; expect false
     }
 }

main/src/main/java/org/minerift/ether/debug/SchematicDebugCommand.java

@@ -28,7 +28,7 @@ public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command
         }
 
         final Player plr = (Player) sender;
-        final Vec3i pos = BukkitUtils.getPosAsVec3i(plr.getLocation());
+        final Vec3i pos = BukkitUtils.asVec3i(plr.getLocation());
         final String worldName = plr.getWorld().getName();
 
         final String[] filePaths = {

main/src/main/java/org/minerift/ether/island/Island.java

@@ -1,9 +1,9 @@
 package org.minerift.ether.island;
 
 import org.bukkit.Chunk;
-import org.bukkit.Location;
 import org.bukkit.World;
 import org.minerift.ether.user.EtherUser;
+import org.minerift.ether.util.math.Vec2i;
 
 import java.util.EnumSet;
 import java.util.HashSet;
@@ -16,7 +16,7 @@ public class Island {
 
     // These 2 pieces of data can be calculated from each other
     private int id;
-    private Tile tile;
+    private Vec2i tile;
 
     // Team related fields
     private int maxTeamSize;
@@ -48,7 +48,7 @@ public int getId() {
         return id;
     }
 
-    public Tile getTile() {
+    public Vec2i getTile() {
         return tile;
     }
 
@@ -106,7 +106,7 @@ public static Island.Builder builder() {
 
     public static class Builder {
 
-        private Tile tile;
+        private Vec2i tile;
         private int id;
         private long topLeftBound, bottomRightBound;
         private boolean isDeleted = false;
@@ -121,9 +121,9 @@ public static class Builder {
          * @param withId Whether the builder should also set the id from tile
          * @return
          */
-        public Builder setTile(Tile tile, boolean withId) {
+        public Builder setTile(Vec2i tile, boolean withId) {
             this.tile = tile;
-            if(withId) this.id = tile.getId();
+            if(withId) this.id = tile.getTileId();
             return this;
         }
 
@@ -134,19 +134,19 @@ public Builder setDeleted(boolean isDeleted) {
 
         public Builder definePermissions(IslandRole role, EnumSet<IslandPermission> rolePermissions) {
             this.permissions = new PermissionSet();
-            permissions.setPermissions(role, rolePermissions);
+            permissions.set(role, rolePermissions);
             return this;
         }
 
         public Builder definePermissions(IslandRole role, IslandPermission ... rolePermissions) {
             this.permissions = new PermissionSet();
-            permissions.setPermissions(role, rolePermissions);
+            permissions.set(role, rolePermissions);
             return this;
         }
 
         public Builder setPermission(IslandRole role, IslandPermission rolePermission) {
             this.permissions = new PermissionSet();
-            permissions.setPermissions(role, rolePermission);
+            permissions.set(role, rolePermission);
             return this;
         }
 

main/src/main/java/org/minerift/ether/island/IslandCreationRoutine.java

@@ -1,22 +1,26 @@
 package org.minerift.ether.island;
 
-import com.google.common.base.Preconditions;
 import org.bukkit.entity.Player;
 import org.minerift.ether.schematic.SchematicPasteOptions;
 import org.minerift.ether.schematic.types.Schematic;
 import org.minerift.ether.user.EtherUser;
+import org.minerift.ether.util.BukkitUtils;
+import org.minerift.ether.util.math.Vec2i;
 import org.minerift.ether.util.math.Vec3i;
 
 import java.io.File;
 
+import static org.minerift.ether.config.deprecated.MainConfig.TILE_ACCESSIBLE_AREA;
+import static org.minerift.ether.config.deprecated.MainConfig.TILE_SIZE;
+
 public class IslandCreationRoutine {
 
     public static Island run(IslandGrid grid, EtherUser user) {
 
-        Preconditions.checkArgument(user.getOfflinePlayer().isOnline(), "User must be online to create island!");
-        final Player plr = (Player) user.getOfflinePlayer();
+        final Player plr = user.getPlayer().orElseThrow(() -> new IllegalArgumentException("User must be online to create island!"));
 
-        final Tile tile = grid.getNextTile();
+        // Register island on grid
+        final Vec2i tile = grid.getNextTile();
         final Island island = Island.builder()
                 .setTile(tile, true)
                 .setDeleted(false)
@@ -25,14 +29,30 @@ public static Island run(IslandGrid grid, EtherUser user) {
 
         grid.registerIsland(island);
 
-        // TODO: Paste schematic/structure onto tile
-        File file = null;
-        Vec3i pos = Vec3i.ZERO;
+        // Paste island at tile
+        // Refer to the Island Placement Graph (https://www.desmos.com/calculator/fuwvk1rgkf) for easy maths and representation
+        final File file = null; // TODO
+
+        // Get schematic paste position
+        Vec3i.Mutable bottomLeftPos = BukkitUtils.getVec3iAt(tile).asMutable(); // TODO
+        final int bottomLeftOffset = (TILE_SIZE / 2) - (TILE_ACCESSIBLE_AREA / 2);
+        bottomLeftPos.add(bottomLeftOffset, 0, bottomLeftOffset);
+
         Schematic.fromFile(file).handle((schem) -> {
-            schem.paste(pos, plr.getWorld().getName(), SchematicPasteOptions.builder().copyBiomes(true).build());
+
+            final SchematicPasteOptions options = SchematicPasteOptions.builder()
+                    .setOffset(bottomLeftPos)
+                    .copyBiomes(true)
+                    .copyEntities(false)
+                    .ignoreAirBlocks(false)
+                    .build();
+
+            schem.paste(bottomLeftPos, plr.getWorld().getName(), options);
+
         }, (ex) -> { throw new RuntimeException(ex); });
 
         // Teleport player
+        // TODO: find sign and spawn player in front
 
         return island;
 

main/src/main/java/org/minerift/ether/island/IslandGrid.java

@@ -4,6 +4,7 @@
 import com.google.common.collect.ImmutableList;
 import org.minerift.ether.GridAlgorithm;
 import org.minerift.ether.util.SortedList;
+import org.minerift.ether.util.math.Vec2i;
 
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -44,19 +45,33 @@ public void registerIsland(Island island) {
         islands.add(island);
     }
 
-    public Optional<Island> getIslandAt(Tile tile) {
+    // Returns an island at a given tile, deleted or not
+    public Optional<Island> getIslandAt(Vec2i tile) {
+        return getIslandAt(tile, false);
+    }
+
+    // Returns an island at a given tile.
+    // If activeOnly, return the island only if active.
+    public Optional<Island> getIslandAt(Vec2i tile, boolean activeOnly) {
+
+        // Get island at tile location
         final int id = GridAlgorithm.computeTileId(tile);
         Island island = id >= islands.size() ? null : islands.get(id);
+
+        // Handle activeOnly
+        if(activeOnly) {
+            island = island != null && !island.isDeleted() ? island : null;
+        }
         return Optional.ofNullable(island);
     }
 
     // Returns whether a tile has an island, deleted or not, present
-    public boolean isTileOccupied(Tile tile) {
+    public boolean isTileOccupied(Vec2i tile) {
         return getIslandAt(tile).isPresent();
     }
 
     // Returns whether a tile has an active island (not deleted)
-    public boolean hasActiveIslandAtTile(Tile tile) {
+    public boolean hasActiveIslandAtTile(Vec2i tile) {
         AtomicBoolean isActive = new AtomicBoolean(false);
         getIslandAt(tile).ifPresent((island) -> isActive.set(!island.isDeleted()));
         return isActive.get();
@@ -74,7 +89,7 @@ public ImmutableList<Island> getIslandsView() {
     }
 
     // Returns the next available tile that can be occupied
-    public Tile getNextTile() {
+    public Vec2i getNextTile() {
         ImmutableList<Island> purgedIslands = getPurgedIslandsView();
         return purgedIslands.isEmpty()
                 ? getNextTileFromGridBounds()
@@ -90,7 +105,7 @@ private int getNextIdFromGridBounds() {
     }
 
     // Returns the next tile at the end of the grid
-    private Tile getNextTileFromGridBounds() {
+    private Vec2i getNextTileFromGridBounds() {
         return GridAlgorithm.computeTile(getNextIdFromGridBounds());
     }
 
@@ -120,7 +135,7 @@ private void validateGridContiguity() {
                 .filter(id -> !excludedIds.contains(id))
                 .forEachOrdered(id -> {
 
-                    Tile tile = GridAlgorithm.computeTile(id);
+                    Vec2i tile = GridAlgorithm.computeTile(id);
                     Island fillerIsland = Island.builder()
                             .setTile(tile, true)
                             .setDeleted(true) // tile can be overwritten

main/src/main/java/org/minerift/ether/island/PermissionSet.java

@@ -11,58 +11,58 @@ public PermissionSet() {
         this.permissionSet = new EnumMap<>(IslandRole.class);
     }
 
-    public void setPermissions(IslandRole role, IslandPermission ... permissionsArr) {
+    public void set(IslandRole role, IslandPermission ... permissionsArr) {
         EnumSet<IslandPermission> permissions = EnumSet.noneOf(IslandPermission.class);
         Collections.addAll(permissions, permissionsArr);
-        setPermissions(role, permissions);
+        set(role, permissions);
     }
 
-    public void setPermissions(IslandRole role, EnumSet<IslandPermission> permissions) {
+    public void set(IslandRole role, EnumSet<IslandPermission> permissions) {
         permissionSet.put(role, permissions);
     }
 
-    public EnumSet<IslandPermission> getPermissions(IslandRole role) {
+    public EnumSet<IslandPermission> get(IslandRole role) {
         return permissionSet.get(role);
     }
 
-    public boolean hasPermission(IslandRole role, IslandPermission permission) {
+    public boolean has(IslandRole role, IslandPermission permission) {
         return permissionSet.get(role).contains(permission);
     }
 
-    public boolean hasPermissions(IslandRole role, IslandPermission ... permissionsArr) {
+    public boolean has(IslandRole role, IslandPermission ... permissionsArr) {
         EnumSet<IslandPermission> permissions = EnumSet.noneOf(IslandPermission.class);
         Collections.addAll(permissions, permissionsArr);
-        return hasPermissions(role, permissions);
+        return has(role, permissions);
     }
 
-    public boolean hasPermissions(IslandRole role, EnumSet<IslandPermission> permissions) {
+    public boolean has(IslandRole role, EnumSet<IslandPermission> permissions) {
         return permissionSet.get(role).containsAll(permissions);
     }
 
-    public void addPermission(IslandRole role, IslandPermission rolePermission) {
+    public void add(IslandRole role, IslandPermission rolePermission) {
         permissionSet.get(role).add(rolePermission);
     }
 
-    public void addPermissions(IslandRole role, EnumSet<IslandPermission> rolePermissions) {
+    public void add(IslandRole role, EnumSet<IslandPermission> rolePermissions) {
         permissionSet.get(role).addAll(rolePermissions);
     }
 
-    public void addPermissions(IslandRole role, IslandPermission ... rolePermissions) {
+    public void add(IslandRole role, IslandPermission ... rolePermissions) {
         EnumSet<IslandPermission> set = Arrays.stream(rolePermissions).collect(Collectors.toCollection(() -> EnumSet.noneOf(IslandPermission.class)));
-        addPermissions(role, set);
+        add(role, set);
     }
 
-    public void removePermission(IslandRole role, IslandPermission rolePermission) {
+    public void remove(IslandRole role, IslandPermission rolePermission) {
         permissionSet.get(role).remove(rolePermission);
     }
 
-    public void removePermissions(IslandRole role, EnumSet<IslandPermission> rolePermissions) {
+    public void remove(IslandRole role, EnumSet<IslandPermission> rolePermissions) {
         permissionSet.get(role).removeAll(rolePermissions);
     }
 
-    public void removePermissions(IslandRole role, IslandPermission ... rolePermissions) {
+    public void remove(IslandRole role, IslandPermission ... rolePermissions) {
         EnumSet<IslandPermission> set = Arrays.stream(rolePermissions).collect(Collectors.toCollection(() -> EnumSet.noneOf(IslandPermission.class)));
-        removePermissions(role, set);
+        remove(role, set);
     }
 
 }

main/src/main/java/org/minerift/ether/schematic/SchematicPasteOptions.java

@@ -8,7 +8,7 @@ public class SchematicPasteOptions {
      * Default SchematicPasteOptions with no changes.
      * Everything is defaulted to false or 0.
      */
-    public static final SchematicPasteOptions EMPTY_DEFAULT;
+    public static final SchematicPasteOptions IDENTITY;
 
     /**
      * Preferred default SchematicPasteOptions.
@@ -17,7 +17,7 @@ public class SchematicPasteOptions {
     public static final SchematicPasteOptions DEFAULT;
 
     static {
-        EMPTY_DEFAULT = SchematicPasteOptions.builder().build();
+        IDENTITY = SchematicPasteOptions.builder().build();
         DEFAULT = SchematicPasteOptions.builder()
                 .copyBiomes(true)
                 .copyEntities(true)

main/src/main/java/org/minerift/ether/schematic/types/SchematicType.java

@@ -30,15 +30,19 @@ private SchematicType(ISchematicReader<? extends Schematic> reader, ISchematicPa
         this.paster = paster;
     }
 
+    public boolean isSupported() {
+        return this != UNSUPPORTED;
+    }
+
     public ISchematicReader<? extends Schematic> getReader() {
-        if(this == UNSUPPORTED) {
+        if(!isSupported()) {
             throw new UnsupportedOperationException("Reader unavailable because schematic type was unable to load!");
         }
         return reader;
     }
 
     public ISchematicPaster<? extends Schematic> getPaster() {
-        if(this == UNSUPPORTED) {
+        if(!isSupported()) {
             throw new UnsupportedOperationException("Paster unavailable because schematic type was unable to load!");
         }
         return paster;