From 05ab44d50b9048ddf69e27afc803dad56ab06526 Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Thu, 6 Aug 2020 15:58:21 -0400 Subject: [PATCH] Revert "Block Compat" This reverts commit 2a849c417f1d564f53caf8ad0b8d6e7926788608. --- .../iris/gen/ContextualChunkGenerator.java | 10 +- .../iris/gen/DimensionChunkGenerator.java | 3 +- .../iris/gen/TerrainChunkGenerator.java | 12 +- .../volmit/iris/gen/atomics/AtomicCache.java | 46 +- .../volmit/iris/gen/atomics/AtomicSliver.java | 8 +- .../volmit/iris/gen/layer/GenLayerCave.java | 8 +- .../iris/gen/post/PostFloatingNibDeleter.java | 4 +- .../volmit/iris/gen/post/PostWaterlogger.java | 4 +- .../gen/standalone/StandaloneBiomeGrid.java | 40 + .../gen/standalone/StandaloneChunkData.java | 81 + .../iris/gen/standalone/StandaloneWorld.java | 1364 +++++++++++++++++ .../iris/object/IrisBiomeDecorator.java | 4 +- .../iris/object/IrisBiomePaletteLayer.java | 4 +- .../iris/object/IrisCompatabilityFilter.java | 18 +- .../iris/object/IrisDepositGenerator.java | 6 +- .../com/volmit/iris/object/IrisDimension.java | 64 +- .../com/volmit/iris/object/IrisObject.java | 8 +- .../volmit/iris/object/IrisObjectReplace.java | 6 +- .../iris/util/{B.java => BlockDataTools.java} | 90 +- .../java/com/volmit/iris/util/Consumer2.java | 1 - .../java/com/volmit/iris/util/Consumer3.java | 1 - .../java/com/volmit/iris/util/Function2.java | 1 - .../java/com/volmit/iris/util/Function3.java | 1 - .../java/com/volmit/iris/util/Function4.java | 1 - 24 files changed, 1573 insertions(+), 212 deletions(-) create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java create mode 100644 src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java rename src/main/java/com/volmit/iris/util/{B.java => BlockDataTools.java} (60%) diff --git a/src/main/java/com/volmit/iris/gen/ContextualChunkGenerator.java b/src/main/java/com/volmit/iris/gen/ContextualChunkGenerator.java index 6256884a0..d7ef41b5f 100644 --- a/src/main/java/com/volmit/iris/gen/ContextualChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/ContextualChunkGenerator.java @@ -23,7 +23,7 @@ import org.bukkit.generator.ChunkGenerator; import com.volmit.iris.Iris; import com.volmit.iris.IrisContext; import com.volmit.iris.IrisMetrics; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CNG; import com.volmit.iris.util.ChronoLatch; import com.volmit.iris.util.J; @@ -220,12 +220,12 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements if(j == i || j + i == 16) { - c.setBlock(i, h, j, B.getBlockData("RED_TERRACOTTA")); + c.setBlock(i, h, j, BlockDataTools.getBlockData("RED_TERRACOTTA")); } else { - c.setBlock(i, h, j, B.getBlockData("BLACK_TERRACOTTA")); + c.setBlock(i, h, j, BlockDataTools.getBlockData("BLACK_TERRACOTTA")); } } } @@ -245,12 +245,12 @@ public abstract class ContextualChunkGenerator extends ChunkGenerator implements if(j == i || j + i == 16) { - c.setBlock(i, h, j, B.getBlockData("BLUE_TERRACOTTA")); + c.setBlock(i, h, j, BlockDataTools.getBlockData("BLUE_TERRACOTTA")); } else { - c.setBlock(i, h, j, B.getBlockData("WHITE_TERRACOTTA")); + c.setBlock(i, h, j, BlockDataTools.getBlockData("WHITE_TERRACOTTA")); } } } diff --git a/src/main/java/com/volmit/iris/gen/DimensionChunkGenerator.java b/src/main/java/com/volmit/iris/gen/DimensionChunkGenerator.java index 0f0ba5d65..10f01f7fc 100644 --- a/src/main/java/com/volmit/iris/gen/DimensionChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/DimensionChunkGenerator.java @@ -8,7 +8,6 @@ import com.volmit.iris.object.InferredType; import com.volmit.iris.object.IrisBiome; import com.volmit.iris.object.IrisDimension; import com.volmit.iris.object.IrisRegion; -import com.volmit.iris.util.B; import com.volmit.iris.util.BiomeResult; import lombok.Data; @@ -20,7 +19,7 @@ public abstract class DimensionChunkGenerator extends ContextualChunkGenerator { protected final String dimensionName; protected static final BlockData AIR = Material.AIR.createBlockData(); - protected static final BlockData CAVE_AIR = B.get("CAVE_AIR"); + protected static final BlockData CAVE_AIR = Material.CAVE_AIR.createBlockData(); protected static final BlockData BEDROCK = Material.BEDROCK.createBlockData(); public DimensionChunkGenerator(String dimensionName) diff --git a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java index 2e07f4ac2..89cd22be0 100644 --- a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java @@ -18,7 +18,7 @@ import com.volmit.iris.object.IrisDepositGenerator; import com.volmit.iris.object.IrisRegion; import com.volmit.iris.util.BiomeMap; import com.volmit.iris.util.BiomeResult; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CaveResult; import com.volmit.iris.util.HeightMap; import com.volmit.iris.util.IrisLock; @@ -323,7 +323,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator if(d != null) { - if(!B.canPlaceOnto(d.getMaterial(), block.getMaterial())) + if(!BlockDataTools.canPlaceOnto(d.getMaterial(), block.getMaterial())) { continue; } @@ -332,7 +332,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator { if(!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND)) { - sliver.set(k, B.getBlockData("RED_SAND")); + sliver.set(k, BlockDataTools.getBlockData("RED_SAND")); } } @@ -340,7 +340,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator { if(!block.getMaterial().equals(Material.FARMLAND)) { - sliver.set(k, B.getBlockData("FARMLAND")); + sliver.set(k, BlockDataTools.getBlockData("FARMLAND")); } } @@ -392,7 +392,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator if(d != null) { - if(!B.canPlaceOnto(d.getMaterial(), block.getMaterial())) + if(!BlockDataTools.canPlaceOnto(d.getMaterial(), block.getMaterial())) { continue; } @@ -401,7 +401,7 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator { if(!block.getMaterial().equals(Material.SAND) && !block.getMaterial().equals(Material.RED_SAND)) { - sliver.set(k, B.getBlockData("SAND")); + sliver.set(k, BlockDataTools.getBlockData("SAND")); } } diff --git a/src/main/java/com/volmit/iris/gen/atomics/AtomicCache.java b/src/main/java/com/volmit/iris/gen/atomics/AtomicCache.java index a6a7c2409..cfe4cf6ad 100644 --- a/src/main/java/com/volmit/iris/gen/atomics/AtomicCache.java +++ b/src/main/java/com/volmit/iris/gen/atomics/AtomicCache.java @@ -9,15 +9,13 @@ public class AtomicCache { private transient volatile T t; private transient volatile long a; - private boolean nullSupport; private transient volatile int validations; private final IrisLock check; private final IrisLock time; private final IrisLock write; - public AtomicCache(boolean nullSupport) + public AtomicCache() { - this.nullSupport = nullSupport; check = new IrisLock("Check"); write = new IrisLock("Write"); time = new IrisLock("Time"); @@ -26,11 +24,6 @@ public class AtomicCache t = null; } - public AtomicCache() - { - this(false); - } - public void reset() { check.lock(); @@ -43,43 +36,8 @@ public class AtomicCache check.unlock(); } - public T aquireNullex(Supplier t) - { - if(validations > 1000) - { - return this.t; - } - - if(M.ms() - a > 1000) - { - validations++; - return this.t; - } - - check.lock(); - write.lock(); - this.t = t.get(); - - time.lock(); - - if(a == -1) - { - a = M.ms(); - } - - time.unlock(); - write.unlock(); - check.unlock(); - return this.t; - } - public T aquire(Supplier t) { - if(nullSupport) - { - return aquireNullex(t); - } - if(this.t != null && validations > 1000) { return this.t; @@ -97,7 +55,7 @@ public class AtomicCache check.lock(); - if(this.t != null) + if(this.t == null) { write.lock(); this.t = t.get(); diff --git a/src/main/java/com/volmit/iris/gen/atomics/AtomicSliver.java b/src/main/java/com/volmit/iris/gen/atomics/AtomicSliver.java index 1d85537d0..2e28a64a6 100644 --- a/src/main/java/com/volmit/iris/gen/atomics/AtomicSliver.java +++ b/src/main/java/com/volmit/iris/gen/atomics/AtomicSliver.java @@ -11,7 +11,7 @@ import org.bukkit.generator.ChunkGenerator.BiomeGrid; import org.bukkit.generator.ChunkGenerator.ChunkData; import com.volmit.iris.object.IrisBiome; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.HeightMap; import com.volmit.iris.util.IrisLock; import com.volmit.iris.util.KList; @@ -23,7 +23,7 @@ import lombok.Data; @Data public class AtomicSliver { - public static final BlockData AIR = B.getBlockData("AIR"); + public static final BlockData AIR = BlockDataTools.getBlockData("AIR"); private KMap block; private KMap truebiome; private KMap biome; @@ -75,7 +75,7 @@ public class AtomicSliver lock.unlock(); modified = true; - if(d.getMaterial().equals(Material.AIR) || d.getMaterial().equals(B.mat("CAVE_AIR"))) + if(d.getMaterial().equals(Material.AIR) || d.getMaterial().equals(Material.CAVE_AIR)) { return; } @@ -181,7 +181,7 @@ public class AtomicSliver for(int i = 0; i < p; i++) { - palette.add(B.getBlockData(din.readUTF())); + palette.add(BlockDataTools.getBlockData(din.readUTF())); } for(int i = 0; i <= h; i++) diff --git a/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java b/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java index 8321825fa..f6ccb0e25 100644 --- a/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java +++ b/src/main/java/com/volmit/iris/gen/layer/GenLayerCave.java @@ -5,7 +5,7 @@ import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.DimensionChunkGenerator; import com.volmit.iris.gen.atomics.AtomicSliver; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CNG; import com.volmit.iris.util.CaveResult; import com.volmit.iris.util.FastNoise; @@ -18,8 +18,8 @@ import com.volmit.iris.util.FastNoise.NoiseType; public class GenLayerCave extends GenLayer { - public static final BlockData CAVE_AIR = B.getBlockData("CAVE_AIR"); - public static final BlockData AIR = B.getBlockData("AIR"); + public static final BlockData CAVE_AIR = BlockDataTools.getBlockData("CAVE_AIR"); + public static final BlockData AIR = BlockDataTools.getBlockData("AIR"); private static final KList EMPTY = new KList<>(); private CNG gincline; private CNG shuffle; @@ -174,7 +174,7 @@ public class GenLayerCave extends GenLayer public boolean canAir(Material m) { - return (m.isSolid() || (B.isDecorant(m)) || m.equals(Material.AIR) || m.equals(B.mat("CAVE_AIR"))) && !m.equals(Material.BEDROCK); + return (m.isSolid() || (BlockDataTools.isDecorant(m)) || m.equals(Material.AIR) || m.equals(Material.CAVE_AIR)) && !m.equals(Material.BEDROCK); } public boolean canWater(Material m) diff --git a/src/main/java/com/volmit/iris/gen/post/PostFloatingNibDeleter.java b/src/main/java/com/volmit/iris/gen/post/PostFloatingNibDeleter.java index 6826396d8..93c40fbd5 100644 --- a/src/main/java/com/volmit/iris/gen/post/PostFloatingNibDeleter.java +++ b/src/main/java/com/volmit/iris/gen/post/PostFloatingNibDeleter.java @@ -3,13 +3,13 @@ package com.volmit.iris.gen.post; import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.PostBlockChunkGenerator; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.IrisPostBlockFilter; @Post("floating-block-remover") public class PostFloatingNibDeleter extends IrisPostBlockFilter { - private static final BlockData AIR = B.getBlockData("AIR"); + private static final BlockData AIR = BlockDataTools.getBlockData("AIR"); public PostFloatingNibDeleter(PostBlockChunkGenerator gen, int phase) { diff --git a/src/main/java/com/volmit/iris/gen/post/PostWaterlogger.java b/src/main/java/com/volmit/iris/gen/post/PostWaterlogger.java index 089633ae5..6ebd2f85e 100644 --- a/src/main/java/com/volmit/iris/gen/post/PostWaterlogger.java +++ b/src/main/java/com/volmit/iris/gen/post/PostWaterlogger.java @@ -5,13 +5,13 @@ import org.bukkit.block.data.BlockData; import org.bukkit.block.data.Waterlogged; import com.volmit.iris.gen.PostBlockChunkGenerator; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.IrisPostBlockFilter; @Post("waterlogger") public class PostWaterlogger extends IrisPostBlockFilter { - private static final BlockData WATER = B.getBlockData("WATER"); + private static final BlockData WATER = BlockDataTools.getBlockData("WATER"); public PostWaterlogger(PostBlockChunkGenerator gen, int phase) { diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java new file mode 100644 index 000000000..32ec9860d --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneBiomeGrid.java @@ -0,0 +1,40 @@ +package com.volmit.iris.gen.standalone; + +import org.bukkit.block.Biome; +import org.bukkit.generator.ChunkGenerator.BiomeGrid; + +import com.volmit.iris.util.BiomeStorage; + +public class StandaloneBiomeGrid implements BiomeGrid +{ + private final BiomeStorage storage; + + public StandaloneBiomeGrid() + { + storage = new BiomeStorage(); + } + + @Override + public Biome getBiome(int x, int z) + { + throw new UnsupportedOperationException("Use GetBiome x, y, z"); + } + + @Override + public Biome getBiome(int x, int y, int z) + { + return storage.getBiome(x, y, z); + } + + @Override + public void setBiome(int arg0, int arg1, Biome arg2) + { + throw new UnsupportedOperationException("Use SetBiome x, y, z, b"); + } + + @Override + public void setBiome(int x, int y, int z, Biome b) + { + storage.setBiome(x, y, z, b); + } +} diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java new file mode 100644 index 000000000..0a4e2a6ff --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneChunkData.java @@ -0,0 +1,81 @@ +package com.volmit.iris.gen.standalone; + +import org.bukkit.Material; +import org.bukkit.block.data.BlockData; +import org.bukkit.generator.ChunkGenerator.ChunkData; +import org.bukkit.material.MaterialData; + +import com.volmit.iris.gen.atomics.AtomicSliverMap; + +@SuppressWarnings("deprecation") +public class StandaloneChunkData extends AtomicSliverMap implements ChunkData +{ + @Override + public BlockData getBlockData(int x, int y, int z) + { + return getSliver(x, z).get(y); + } + + @Override + public byte getData(int x, int y, int z) + { + throw new UnsupportedOperationException("Use getBlockData"); + } + + @Override + public int getMaxHeight() + { + return 256; + } + + @Override + public Material getType(int x, int y, int z) + { + return getBlockData(x, y, z).getMaterial(); + } + + @Deprecated + @Override + public MaterialData getTypeAndData(int x, int y, int z) + { + throw new UnsupportedOperationException("Use GetBlockData"); + } + + @Override + public void setBlock(int x, int y, int z, Material arg3) + { + setBlock(x, y, z, arg3.createBlockData()); + } + + @Deprecated + @Override + public void setBlock(int arg0, int arg1, int arg2, MaterialData arg3) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Override + public void setBlock(int x, int y, int z, BlockData b) + { + getSliver(x, z).set(y, b); + } + + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, Material arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Deprecated + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, MaterialData arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } + + @Override + public void setRegion(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5, BlockData arg6) + { + throw new UnsupportedOperationException("Use SetBlock (bd)"); + } +} diff --git a/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java b/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java new file mode 100644 index 000000000..dfef7be62 --- /dev/null +++ b/src/main/java/com/volmit/iris/gen/standalone/StandaloneWorld.java @@ -0,0 +1,1364 @@ +package com.volmit.iris.gen.standalone; + +import java.io.File; +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; +import java.util.function.Predicate; + +import org.bukkit.BlockChangeDelegate; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.Difficulty; +import org.bukkit.Effect; +import org.bukkit.FluidCollisionMode; +import org.bukkit.GameRule; +import org.bukkit.HeightMap; +import org.bukkit.Location; +import org.bukkit.Material; +import org.bukkit.Particle; +import org.bukkit.Raid; +import org.bukkit.Sound; +import org.bukkit.SoundCategory; +import org.bukkit.StructureType; +import org.bukkit.TreeType; +import org.bukkit.World; +import org.bukkit.WorldBorder; +import org.bukkit.WorldType; +import org.bukkit.block.Biome; +import org.bukkit.block.Block; +import org.bukkit.block.data.BlockData; +import org.bukkit.boss.DragonBattle; +import org.bukkit.entity.AbstractArrow; +import org.bukkit.entity.Arrow; +import org.bukkit.entity.Entity; +import org.bukkit.entity.EntityType; +import org.bukkit.entity.FallingBlock; +import org.bukkit.entity.Item; +import org.bukkit.entity.LightningStrike; +import org.bukkit.entity.LivingEntity; +import org.bukkit.entity.Player; +import org.bukkit.generator.BlockPopulator; +import org.bukkit.generator.ChunkGenerator; +import org.bukkit.inventory.ItemStack; +import org.bukkit.material.MaterialData; +import org.bukkit.metadata.MetadataValue; +import org.bukkit.plugin.Plugin; +import org.bukkit.util.BoundingBox; +import org.bukkit.util.Consumer; +import org.bukkit.util.RayTraceResult; +import org.bukkit.util.Vector; + +@SuppressWarnings("deprecation") +public class StandaloneWorld implements World +{ + private final long seed; + private final String name; + private final File folder; + + public StandaloneWorld(String name, long seed, File folder) + { + this.seed = seed; + this.name = name; + this.folder = folder; + } + + @Override + public Set getListeningPluginChannels() + { + throw new UnsupportedOperationException(); + } + + @Override + public void sendPluginMessage(Plugin arg0, String arg1, byte[] arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getMetadata(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean hasMetadata(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void removeMetadata(String arg0, Plugin arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setMetadata(String arg0, MetadataValue arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean addPluginChunkTicket(int arg0, int arg1, Plugin arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean canGenerateStructures() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(Location arg0, float arg1, boolean arg2, boolean arg3, Entity arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4, boolean arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean createExplosion(double arg0, double arg1, double arg2, float arg3, boolean arg4, boolean arg5, Entity arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Item dropItem(Location arg0, ItemStack arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Item dropItemNaturally(Location arg0, ItemStack arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean generateTree(Location arg0, TreeType arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean generateTree(Location arg0, TreeType arg1, BlockChangeDelegate arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getAllowAnimals() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getAllowMonsters() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getAmbientSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getAnimalSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Biome getBiome(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Biome getBiome(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getBlockAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getBlockAt(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(Block arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk getChunkAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Difficulty getDifficulty() + { + throw new UnsupportedOperationException(); + + } + + @Override + public ChunkSnapshot getEmptyChunkSnapshot(int arg0, int arg1, boolean arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public DragonBattle getEnderDragonBattle() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getEntities() + { + throw new UnsupportedOperationException(); + + } + + @SuppressWarnings("unchecked") + @Override + public Collection getEntitiesByClass(Class... arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getEntitiesByClass(Class arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getEntitiesByClasses(Class... arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Environment getEnvironment() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getForceLoadedChunks() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getFullTime() + { + throw new UnsupportedOperationException(); + + } + + @Override + public T getGameRuleDefault(GameRule arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public String getGameRuleValue(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T getGameRuleValue(GameRule arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public String[] getGameRules() + { + throw new UnsupportedOperationException(); + + } + + @Override + public ChunkGenerator getGenerator() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(Location arg0, HeightMap arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Block getHighestBlockAt(int arg0, int arg1, HeightMap arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(Location arg0, HeightMap arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getHighestBlockYAt(int arg0, int arg1, HeightMap arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getHumidity(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getHumidity(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getKeepSpawnInMemory() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getLivingEntities() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Chunk[] getLoadedChunks() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getMaxHeight() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getMonsterSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public String getName() + { + return name; + } + + @Override + public Collection getNearbyEntities(BoundingBox arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(BoundingBox arg0, Predicate arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(Location arg0, double arg1, double arg2, double arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getNearbyEntities(Location arg0, double arg1, double arg2, double arg3, Predicate arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean getPVP() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getPlayers() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Map> getPluginChunkTickets() + { + throw new UnsupportedOperationException(); + + } + + @Override + public Collection getPluginChunkTickets(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getPopulators() + { + throw new UnsupportedOperationException(); + + } + + @Override + public List getRaids() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getSeaLevel() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getSeed() + { + return seed; + } + + @Override + public Location getSpawnLocation() + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getTemperature(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public double getTemperature(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getThunderDuration() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerAmbientSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerAnimalSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerMonsterSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerWaterAmbientSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTicksPerWaterSpawns() + { + throw new UnsupportedOperationException(); + + } + + @Override + public long getTime() + { + throw new UnsupportedOperationException(); + + } + + @Override + public UUID getUID() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getViewDistance() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWaterAmbientSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWaterAnimalSpawnLimit() + { + throw new UnsupportedOperationException(); + + } + + @Override + public int getWeatherDuration() + { + throw new UnsupportedOperationException(); + + } + + @Override + public WorldBorder getWorldBorder() + { + throw new UnsupportedOperationException(); + + } + + @Override + public File getWorldFolder() + { + return folder; + } + + @Override + public WorldType getWorldType() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean hasStorm() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isAutoSave() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkForceLoaded(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkGenerated(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkInUse(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkLoaded(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isChunkLoaded(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isGameRule(String arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isHardcore() + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean isThundering() + { + throw new UnsupportedOperationException(); + + } + + @Override + public void loadChunk(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void loadChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean loadChunk(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Raid locateNearestRaid(Location arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Location locateNearestStructure(Location arg0, StructureType arg1, int arg2, boolean arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, T arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, int arg2, int arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playEffect(Location arg0, Effect arg1, T arg2, int arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, Sound arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, String arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, Sound arg1, SoundCategory arg2, float arg3, float arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void playSound(Location arg0, String arg1, SoundCategory arg2, float arg3, float arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTrace(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3, boolean arg4, double arg5, Predicate arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceBlocks(Location arg0, Vector arg1, double arg2, FluidCollisionMode arg3, boolean arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, double arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, Predicate arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public RayTraceResult rayTraceEntities(Location arg0, Vector arg1, double arg2, double arg3, Predicate arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean refreshChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean regenerateChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean removePluginChunkTicket(int arg0, int arg1, Plugin arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void removePluginChunkTickets(Plugin arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void save() + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAmbientSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAnimalSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setAutoSave(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setBiome(int arg0, int arg1, Biome arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setBiome(int arg0, int arg1, int arg2, Biome arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setChunkForceLoaded(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setDifficulty(Difficulty arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setFullTime(long arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setGameRule(GameRule arg0, T arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setGameRuleValue(String arg0, String arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setHardcore(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setKeepSpawnInMemory(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setMonsterSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setPVP(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setSpawnFlags(boolean arg0, boolean arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setSpawnLocation(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean setSpawnLocation(int arg0, int arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setStorm(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setThunderDuration(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setThundering(boolean arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerAmbientSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerAnimalSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerMonsterSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerWaterAmbientSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTicksPerWaterSpawns(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setTime(long arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWaterAmbientSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWaterAnimalSpawnLimit(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void setWeatherDuration(int arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawn(Location arg0, Class arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawn(Location arg0, Class arg1, Consumer arg2) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public Arrow spawnArrow(Location arg0, Vector arg1, float arg2, float arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public T spawnArrow(Location arg0, Vector arg1, float arg2, float arg3, Class arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Entity spawnEntity(Location arg0, EntityType arg1) + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, MaterialData arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, BlockData arg1) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public FallingBlock spawnFallingBlock(Location arg0, Material arg1, byte arg2) throws IllegalArgumentException + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, T arg3) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, T arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, T arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6, T arg7) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, T arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, Location arg1, int arg2, double arg3, double arg4, double arg5, double arg6, T arg7, boolean arg8) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8, T arg9) + { + throw new UnsupportedOperationException(); + + } + + @Override + public void spawnParticle(Particle arg0, double arg1, double arg2, double arg3, int arg4, double arg5, double arg6, double arg7, double arg8, T arg9, boolean arg10) + { + throw new UnsupportedOperationException(); + + } + + @Override + public Spigot spigot() + { + throw new UnsupportedOperationException(); + + } + + @Override + public LightningStrike strikeLightning(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public LightningStrike strikeLightningEffect(Location arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean unloadChunk(Chunk arg0) + { + throw new UnsupportedOperationException(); + + } + + @Override + public boolean unloadChunk(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + } + + @Override + public boolean unloadChunk(int arg0, int arg1, boolean arg2) + { + throw new UnsupportedOperationException(); + } + + @Override + public boolean unloadChunkRequest(int arg0, int arg1) + { + throw new UnsupportedOperationException(); + } + +} diff --git a/src/main/java/com/volmit/iris/object/IrisBiomeDecorator.java b/src/main/java/com/volmit/iris/object/IrisBiomeDecorator.java index 8a9e5e281..04c4c8ab1 100644 --- a/src/main/java/com/volmit/iris/object/IrisBiomeDecorator.java +++ b/src/main/java/com/volmit/iris/object/IrisBiomeDecorator.java @@ -3,7 +3,7 @@ package com.volmit.iris.object; import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CNG; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; @@ -145,7 +145,7 @@ public class IrisBiomeDecorator KList blockData = new KList<>(); for(String i : palette) { - BlockData bx = B.getBlockData(i); + BlockData bx = BlockDataTools.getBlockData(i); if(bx != null) { blockData.add(bx); diff --git a/src/main/java/com/volmit/iris/object/IrisBiomePaletteLayer.java b/src/main/java/com/volmit/iris/object/IrisBiomePaletteLayer.java index 520ec69a2..dc98dbc4a 100644 --- a/src/main/java/com/volmit/iris/object/IrisBiomePaletteLayer.java +++ b/src/main/java/com/volmit/iris/object/IrisBiomePaletteLayer.java @@ -3,7 +3,7 @@ package com.volmit.iris.object; import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CNG; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; @@ -103,7 +103,7 @@ public class IrisBiomePaletteLayer KList blockData = new KList<>(); for(String ix : palette) { - BlockData bx = B.getBlockData(ix); + BlockData bx = BlockDataTools.getBlockData(ix); if(bx != null) { blockData.add(bx); diff --git a/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java b/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java index fe35e1837..c52c5cc0e 100644 --- a/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java +++ b/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java @@ -2,9 +2,8 @@ package com.volmit.iris.object; import org.bukkit.block.data.BlockData; -import com.volmit.iris.Iris; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; @@ -23,8 +22,8 @@ public class IrisCompatabilityFilter @DontObfuscate private boolean exact = false; - private transient AtomicCache findData = new AtomicCache<>(true); - private transient AtomicCache replaceData = new AtomicCache<>(true); + private transient AtomicCache findData = new AtomicCache<>(); + private transient AtomicCache replaceData = new AtomicCache<>(); public IrisCompatabilityFilter(String when, String supplement) { @@ -45,18 +44,11 @@ public class IrisCompatabilityFilter public BlockData getFind() { - return findData.aquire(() -> B.getBlockData(when)); + return findData.aquire(() -> BlockDataTools.getBlockData(when)); } public BlockData getReplace() { - return replaceData.aquire(() -> - { - BlockData b = B.getBlockData(supplement); - - Iris.warn("Compat: Using " + supplement + " in place of " + when + " since this server doesnt support '" + supplement + "'"); - - return b; - }); + return replaceData.aquire(() -> BlockDataTools.getBlockData(supplement)); } } diff --git a/src/main/java/com/volmit/iris/object/IrisDepositGenerator.java b/src/main/java/com/volmit/iris/object/IrisDepositGenerator.java index 7d1c32633..63d8d3bb5 100644 --- a/src/main/java/com/volmit/iris/object/IrisDepositGenerator.java +++ b/src/main/java/com/volmit/iris/object/IrisDepositGenerator.java @@ -7,7 +7,7 @@ import org.bukkit.util.BlockVector; import com.volmit.iris.gen.TerrainChunkGenerator; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; import com.volmit.iris.util.KList; @@ -114,7 +114,7 @@ public class IrisDepositGenerator for(String ix : palette) { - BlockData bx = B.getBlockData(ix); + BlockData bx = BlockDataTools.getBlockData(ix); if(bx != null) { @@ -178,7 +178,7 @@ public class IrisDepositGenerator BlockData b = data.getBlockData(nx, ny, nz); - if(b.getMaterial().equals(Material.ICE) || b.getMaterial().equals(Material.PACKED_ICE) || b.getMaterial().equals(B.mat("BLUE_ICE")) || b.getMaterial().equals(B.mat("FROSTED_ICE")) || b.getMaterial().equals(Material.SAND) || b.getMaterial().equals(Material.RED_SAND) || !b.getMaterial().isSolid()) + if(b.getMaterial().equals(Material.ICE) || b.getMaterial().equals(Material.SAND) || b.getMaterial().equals(Material.RED_SAND) || !b.getMaterial().isSolid()) { continue; } diff --git a/src/main/java/com/volmit/iris/object/IrisDimension.java b/src/main/java/com/volmit/iris/object/IrisDimension.java index d330266a5..23a4f58da 100644 --- a/src/main/java/com/volmit/iris/object/IrisDimension.java +++ b/src/main/java/com/volmit/iris/object/IrisDimension.java @@ -8,7 +8,7 @@ import org.bukkit.util.BlockVector; import com.volmit.iris.Iris; import com.volmit.iris.gen.PostBlockChunkGenerator; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.CNG; import com.volmit.iris.util.ChunkPosition; import com.volmit.iris.util.Desc; @@ -250,49 +250,15 @@ public class IrisDimension extends IrisRegistrant }); } - public static KList getDefaultCompatability() + private KList getDefaultCompatability() { KList filters = new KList<>(); // Below 1.16 - filters.add(new IrisCompatabilityFilter("WEEPING_VINES", "NETHER_FENCE")); - filters.add(new IrisCompatabilityFilter("WEEPING_VINES_PLANT", "NETHER_FENCE")); - filters.add(new IrisCompatabilityFilter("WARPED_WART_BLOCK", "NETHER_WART_BLOCK")); - filters.add(new IrisCompatabilityFilter("TWISTING_VINES", "BAMBOO")); - filters.add(new IrisCompatabilityFilter("TWISTING_VINES_PLANT", "BAMBOO")); - filters.add(new IrisCompatabilityFilter("TARGET", "COBBLESTONE")); - filters.add(new IrisCompatabilityFilter("SOUL_SOIL", "SOULSAND")); - filters.add(new IrisCompatabilityFilter("SOUL_TORCH", "TORCH")); - filters.add(new IrisCompatabilityFilter("SOUL_LANTERN", "LANTERN")); - filters.add(new IrisCompatabilityFilter("SOUL_FIRE", "FIRE")); - filters.add(new IrisCompatabilityFilter("SOUL_CAMPFIRE", "CAMPFIRE")); - filters.add(new IrisCompatabilityFilter("SHROOMLIGHT", "GLOWSTONE")); - filters.add(new IrisCompatabilityFilter("RESPAWN_ANCHOR", "OBSIDIAN")); - filters.add(new IrisCompatabilityFilter("NETHER_SPROUTS", "RED_MUSHROOM")); - filters.add(new IrisCompatabilityFilter("NETHER_GOLD_ORE", "GOLD_ORE")); - filters.add(new IrisCompatabilityFilter("LODESTONE", "STONE")); - filters.add(new IrisCompatabilityFilter("STRIPPED_WARPED_HYPHAE", "BROWN_MUSHROOM_BLOCK")); - filters.add(new IrisCompatabilityFilter("STRIPPED_CRIMSON_HYPHAE", "RED_MUSHROOM_BLOCK")); - filters.add(new IrisCompatabilityFilter("WARPED_HYPHAE", "MUSHROOM_STEM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_HYPHAE", "RED_MUSHROOM_BLOCK")); - filters.add(new IrisCompatabilityFilter("GILDED_BLACKSTONE", "COBBLESTONE")); - filters.add(new IrisCompatabilityFilter("CRYING_OBSIDIAN", "OBSIDIAN")); - filters.add(new IrisCompatabilityFilter("STRIPPED_WARPED_STEM", "MUSHROOM_STEM")); - filters.add(new IrisCompatabilityFilter("STRIPPED_CRIMSON_STEM", "MUSHROOM_STEM")); - filters.add(new IrisCompatabilityFilter("WARPED_STEM", "MUSHROOM_STEM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_STEM", "MUSHROOM_STEM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_ROOTS", "RED_MUSHROOM")); - filters.add(new IrisCompatabilityFilter("WARPED_ROOTS", "BROWN_MUSHROOM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_PLANKS", "OAK_PLANKS")); - filters.add(new IrisCompatabilityFilter("WARPED_PLANKS", "OAK_PLANKS")); - filters.add(new IrisCompatabilityFilter("WARPED_NYLIUM", "MYCELIUM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_NYLIUM", "MYCELIUM")); - filters.add(new IrisCompatabilityFilter("WARPED_FUNGUS", "BROWN_MUSHROOM")); - filters.add(new IrisCompatabilityFilter("CRIMSON_FUNGUS", "RED_MUSHROOM")); - filters.add(new IrisCompatabilityFilter("CRACKED_NETHER_BRICKS", "NETHER_BRICKS")); + // TODO MORE filters.add(new IrisCompatabilityFilter("CHISELED_NETHER_BRICKS", "NETHER_BRICKS")); filters.add(new IrisCompatabilityFilter("NETHER_FENCE", "LEGACY_NETHER_FENCE")); - filters.add(new IrisCompatabilityFilter("CHAIN", "IRON_BARS")); + filters.add(new IrisCompatabilityFilter("CHAIN", "LEGACY_NETHER_FENCE")); filters.add(new IrisCompatabilityFilter("NETHERITE_BLOCK", "QUARTZ_BLOCK")); filters.add(new IrisCompatabilityFilter("BLACKSTONE", "COBBLESTONE")); filters.add(new IrisCompatabilityFilter("BASALT", "STONE")); @@ -306,7 +272,6 @@ public class IrisDimension extends IrisRegistrant // Below 1.14 filters.add(new IrisCompatabilityFilter("GRANITE_WALL", "COBBLESTONE_WALL")); - filters.add(new IrisCompatabilityFilter("BLUE_ICE", "PACKED_ICE")); filters.add(new IrisCompatabilityFilter("DIORITE_WALL", "COBBLESTONE_WALL")); filters.add(new IrisCompatabilityFilter("ANDESITE_WALL", "COBBLESTONE_WALL")); filters.add(new IrisCompatabilityFilter("SWEET_BERRY_BUSH", "GRASS")); @@ -386,6 +351,7 @@ public class IrisDimension extends IrisRegistrant filters.add(new IrisCompatabilityFilter("BAMBOO", "BIRCH_FENCE")); filters.add(new IrisCompatabilityFilter("BAMBOO_SAPLING", "BIRCH_SAPLING")); filters.add(new IrisCompatabilityFilter("POTTED_BAMBOO", "POTTED_BIRCH_SAPLING")); + filters.add(new IrisCompatabilityFilter("*", "STONE")); return filters; } @@ -404,6 +370,9 @@ public class IrisDimension extends IrisRegistrant { KList p = new KList(); + p.add(new IrisPostProcessor("nib-smoother")); + p.add(new IrisPostProcessor("floating-block-remover")); + p.add(new IrisPostProcessor("pothole-filler")); p.add(new IrisPostProcessor("wall-painter")); p.add(new IrisPostProcessor("slabber")); p.add(new IrisPostProcessor("waterlogger", 1)); @@ -461,7 +430,7 @@ public class IrisDimension extends IrisRegistrant KList rockData = new KList<>(); for(String ix : rockPalette) { - BlockData bx = B.getBlockData(ix); + BlockData bx = BlockDataTools.getBlockData(ix); if(bx != null) { rockData.add(bx); @@ -522,7 +491,7 @@ public class IrisDimension extends IrisRegistrant KList fluidData = new KList<>(); for(String ix : fluidPalette) { - BlockData bx = B.getBlockData(ix); + BlockData bx = BlockDataTools.getBlockData(ix); if(bx != null) { fluidData.add(bx); @@ -641,17 +610,4 @@ public class IrisDimension extends IrisRegistrant return new ChunkPosition(x, z); }); } - - public BlockData resolve(String bd) - { - for(IrisCompatabilityFilter i : getCompatability()) - { - if(i.getWhen().equalsIgnoreCase(bd)) - { - return i.getReplace(); - } - } - - return null; - } } diff --git a/src/main/java/com/volmit/iris/object/IrisObject.java b/src/main/java/com/volmit/iris/object/IrisObject.java index 64305cb21..a74c69df2 100644 --- a/src/main/java/com/volmit/iris/object/IrisObject.java +++ b/src/main/java/com/volmit/iris/object/IrisObject.java @@ -15,7 +15,7 @@ import org.bukkit.block.data.BlockData; import org.bukkit.block.data.type.Leaves; import org.bukkit.util.BlockVector; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.ChunkPosition; import com.volmit.iris.util.IObjectPlacer; import com.volmit.iris.util.KMap; @@ -29,8 +29,8 @@ import lombok.EqualsAndHashCode; public class IrisObject extends IrisRegistrant { private static final Material SNOW = Material.SNOW; - private static final BlockData AIR = B.getBlockData("CAVE_AIR"); - private static final BlockData[] SNOW_LAYERS = new BlockData[] {B.getBlockData("minecraft:snow[layers=1]"), B.getBlockData("minecraft:snow[layers=2]"), B.getBlockData("minecraft:snow[layers=3]"), B.getBlockData("minecraft:snow[layers=4]"), B.getBlockData("minecraft:snow[layers=5]"), B.getBlockData("minecraft:snow[layers=6]"), B.getBlockData("minecraft:snow[layers=7]"), B.getBlockData("minecraft:snow[layers=8]")}; + private static final BlockData AIR = BlockDataTools.getBlockData("CAVE_AIR"); + private static final BlockData[] SNOW_LAYERS = new BlockData[] {BlockDataTools.getBlockData("minecraft:snow[layers=1]"), BlockDataTools.getBlockData("minecraft:snow[layers=2]"), BlockDataTools.getBlockData("minecraft:snow[layers=3]"), BlockDataTools.getBlockData("minecraft:snow[layers=4]"), BlockDataTools.getBlockData("minecraft:snow[layers=5]"), BlockDataTools.getBlockData("minecraft:snow[layers=6]"), BlockDataTools.getBlockData("minecraft:snow[layers=7]"), BlockDataTools.getBlockData("minecraft:snow[layers=8]")}; private KMap blocks; private int w; private int d; @@ -66,7 +66,7 @@ public class IrisObject extends IrisRegistrant for(int i = 0; i < s; i++) { - blocks.put(new BlockVector(din.readShort(), din.readShort(), din.readShort()), B.getBlockData(din.readUTF())); + blocks.put(new BlockVector(din.readShort(), din.readShort(), din.readShort()), BlockDataTools.getBlockData(din.readUTF())); } } diff --git a/src/main/java/com/volmit/iris/object/IrisObjectReplace.java b/src/main/java/com/volmit/iris/object/IrisObjectReplace.java index ceb63ac87..8dbc8c630 100644 --- a/src/main/java/com/volmit/iris/object/IrisObjectReplace.java +++ b/src/main/java/com/volmit/iris/object/IrisObjectReplace.java @@ -3,7 +3,7 @@ package com.volmit.iris.object; import org.bukkit.block.data.BlockData; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.B; +import com.volmit.iris.util.BlockDataTools; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; @@ -32,11 +32,11 @@ public class IrisObjectReplace public BlockData getFind() { - return findData.aquire(() -> B.getBlockData(find)); + return findData.aquire(() -> BlockDataTools.getBlockData(find)); } public BlockData getReplace() { - return replaceData.aquire(() -> B.getBlockData(replace)); + return replaceData.aquire(() -> BlockDataTools.getBlockData(replace)); } } diff --git a/src/main/java/com/volmit/iris/util/B.java b/src/main/java/com/volmit/iris/util/BlockDataTools.java similarity index 60% rename from src/main/java/com/volmit/iris/util/B.java rename to src/main/java/com/volmit/iris/util/BlockDataTools.java index fd968f237..730044fb2 100644 --- a/src/main/java/com/volmit/iris/util/B.java +++ b/src/main/java/com/volmit/iris/util/BlockDataTools.java @@ -5,36 +5,17 @@ import org.bukkit.Material; import org.bukkit.block.data.BlockData; import com.volmit.iris.Iris; -import com.volmit.iris.object.IrisDimension; -public class B +public class BlockDataTools { private static final BlockData AIR = Material.AIR.createBlockData(); private static final KMap bdc = new KMap<>(); private static final KList nulls = new KList<>(); - private static final IrisDimension defaultCompat = new IrisDimension(); - - public static BlockData get(String bd) - { - return getBlockData(bd); - } - - public static Material mat(String bd) - { - return getBlockData(bd).getMaterial(); - } public static BlockData getBlockData(String bd) - { - return getBlockData(bd, defaultCompat); - } - - public static BlockData getBlockData(String bdxf, IrisDimension resolver) { try { - String bd = bdxf.trim(); - if(bdc.containsKey(bd)) { return bdc.get(bd).clone(); @@ -42,11 +23,6 @@ public class B BlockData bdx = parseBlockData(bd); - if(bdx == null) - { - bdx = resolver.resolve(bd); - } - if(bdx == null) { Iris.warn("Unknown Block Data '" + bd + "'"); @@ -61,7 +37,7 @@ public class B catch(Throwable e) { - Iris.warn("Unknown Block Data '" + bdxf + "'"); + Iris.warn("Unknown Block Data '" + bd + "'"); } return AIR; @@ -110,7 +86,7 @@ public class B public static boolean isLit(Material mat) { - if(mat.equals(B.mat("GLOWSTONE")) || mat.equals(B.mat("TORCH")) || mat.equals(Material.REDSTONE_TORCH) || mat.equals(B.mat("SOUL_TORCH")) || mat.equals(Material.REDSTONE_WALL_TORCH) || mat.equals(Material.WALL_TORCH) || mat.equals(B.mat("SOUL_WALL_TORCH")) || mat.equals(B.mat("LANTERN")) || mat.equals(Material.JACK_O_LANTERN) || mat.equals(Material.REDSTONE_LAMP) || mat.equals(Material.MAGMA_BLOCK) || mat.equals(B.mat("SEA_LANTERN")) || mat.equals(B.mat("SOUL_LANTERN")) || mat.equals(Material.FIRE) || mat.equals(B.mat("SOUL_FIRE")) || mat.equals(B.mat("SEA_PICKLE")) || mat.equals(Material.BREWING_STAND) || mat.equals(Material.REDSTONE_ORE)) + if(mat.equals(Material.GLOWSTONE) || mat.equals(Material.TORCH) || mat.equals(Material.REDSTONE_TORCH) || mat.equals(Material.SOUL_TORCH) || mat.equals(Material.REDSTONE_WALL_TORCH) || mat.equals(Material.WALL_TORCH) || mat.equals(Material.SOUL_WALL_TORCH) || mat.equals(Material.LANTERN) || mat.equals(Material.JACK_O_LANTERN) || mat.equals(Material.REDSTONE_LAMP) || mat.equals(Material.MAGMA_BLOCK) || mat.equals(Material.SEA_LANTERN) || mat.equals(Material.SOUL_LANTERN) || mat.equals(Material.FIRE) || mat.equals(Material.SOUL_FIRE) || mat.equals(Material.SEA_PICKLE) || mat.equals(Material.BREWING_STAND) || mat.equals(Material.REDSTONE_ORE)) { return true; } @@ -120,7 +96,7 @@ public class B public static boolean canPlaceOnto(Material mat, Material onto) { - if(onto.equals(Material.AIR) || onto.equals(B.mat("CAVE_AIR"))) + if(onto.equals(Material.AIR) || onto.equals(Material.CAVE_AIR)) { return false; } @@ -138,9 +114,9 @@ public class B } } - if(onto.equals(Material.STONE) || onto.equals(Material.GRAVEL) || onto.equals(Material.GRAVEL) || onto.equals(Material.ANDESITE) || onto.equals(Material.GRANITE) || onto.equals(Material.DIORITE) || onto.equals(B.mat("BLACKSTONE")) || onto.equals(B.mat("BASALT"))) + if(onto.equals(Material.STONE) || onto.equals(Material.GRAVEL) || onto.equals(Material.GRAVEL) || onto.equals(Material.ANDESITE) || onto.equals(Material.GRANITE) || onto.equals(Material.DIORITE) || onto.equals(Material.BLACKSTONE) || onto.equals(Material.BASALT)) { - if(mat.equals(Material.POPPY) || mat.equals(Material.DANDELION) || mat.equals(B.mat("CORNFLOWER")) || mat.equals(Material.ORANGE_TULIP) || mat.equals(Material.PINK_TULIP) || mat.equals(Material.RED_TULIP) || mat.equals(Material.WHITE_TULIP) || mat.equals(Material.FERN) || mat.equals(Material.LARGE_FERN) || mat.equals(Material.GRASS) || mat.equals(Material.TALL_GRASS)) + if(mat.equals(Material.POPPY) || mat.equals(Material.DANDELION) || mat.equals(Material.CORNFLOWER) || mat.equals(Material.ORANGE_TULIP) || mat.equals(Material.PINK_TULIP) || mat.equals(Material.RED_TULIP) || mat.equals(Material.WHITE_TULIP) || mat.equals(Material.FERN) || mat.equals(Material.LARGE_FERN) || mat.equals(Material.GRASS) || mat.equals(Material.TALL_GRASS)) { return false; } @@ -162,7 +138,7 @@ public class B //@builder return m.equals(Material.GRASS) || m.equals(Material.TALL_GRASS) - || m.equals(B.mat("CORNFLOWER")) + || m.equals(Material.CORNFLOWER) || m.equals(Material.SUNFLOWER) || m.equals(Material.CHORUS_FLOWER) || m.equals(Material.POPPY) @@ -174,44 +150,44 @@ public class B || m.equals(Material.WHITE_TULIP) || m.equals(Material.LILAC) || m.equals(Material.DEAD_BUSH) - || m.equals(B.mat("SWEET_BERRY_BUSH")) + || m.equals(Material.SWEET_BERRY_BUSH) || m.equals(Material.ROSE_BUSH) - || m.equals(B.mat("WITHER_ROSE")) + || m.equals(Material.WITHER_ROSE) || m.equals(Material.ALLIUM) || m.equals(Material.BLUE_ORCHID) - || m.equals(B.mat("LILY_OF_THE_VALLEY")) - || m.equals(B.mat("CRIMSON_FUNGUS")) - || m.equals(B.mat("WARPED_FUNGUS")) + || m.equals(Material.LILY_OF_THE_VALLEY) + || m.equals(Material.CRIMSON_FUNGUS) + || m.equals(Material.WARPED_FUNGUS) || m.equals(Material.RED_MUSHROOM) || m.equals(Material.BROWN_MUSHROOM) - || m.equals(B.mat("CRIMSON_ROOTS")) - || m.equals(B.mat("AZURE_BLUET")) - || m.equals(B.mat("WEEPING_VINES")) - || m.equals(B.mat("WEEPING_VINES_PLANT")) - || m.equals(B.mat("WARPED_ROOTS")) - || m.equals(B.mat("NETHER_SPROUTS")) - || m.equals(B.mat("TWISTING_VINES")) - || m.equals(B.mat("TWISTING_VINES_PLANT")) + || m.equals(Material.CRIMSON_ROOTS) + || m.equals(Material.AZURE_BLUET) + || m.equals(Material.WEEPING_VINES) + || m.equals(Material.WEEPING_VINES_PLANT) + || m.equals(Material.WARPED_ROOTS) + || m.equals(Material.NETHER_SPROUTS) + || m.equals(Material.TWISTING_VINES) + || m.equals(Material.TWISTING_VINES_PLANT) || m.equals(Material.SUGAR_CANE) || m.equals(Material.WHEAT) || m.equals(Material.POTATOES) || m.equals(Material.CARROTS) || m.equals(Material.BEETROOTS) || m.equals(Material.NETHER_WART) - || m.equals(B.mat("SEA_PICKLE")) - || m.equals(B.mat("SEAGRASS")) - || m.equals(B.mat("ACACIA_BUTTON")) - || m.equals(B.mat("BIRCH_BUTTON")) - || m.equals(B.mat("CRIMSON_BUTTON")) - || m.equals(B.mat("DARK_OAK_BUTTON")) - || m.equals(B.mat("JUNGLE_BUTTON")) - || m.equals(B.mat("OAK_BUTTON")) - || m.equals(B.mat("POLISHED_BLACKSTONE_BUTTON")) - || m.equals(B.mat("SPRUCE_BUTTON")) - || m.equals(B.mat("STONE_BUTTON")) - || m.equals(B.mat("WARPED_BUTTON")) + || m.equals(Material.SEA_PICKLE) + || m.equals(Material.SEAGRASS) + || m.equals(Material.ACACIA_BUTTON) + || m.equals(Material.BIRCH_BUTTON) + || m.equals(Material.CRIMSON_BUTTON) + || m.equals(Material.DARK_OAK_BUTTON) + || m.equals(Material.JUNGLE_BUTTON) + || m.equals(Material.OAK_BUTTON) + || m.equals(Material.POLISHED_BLACKSTONE_BUTTON) + || m.equals(Material.SPRUCE_BUTTON) + || m.equals(Material.STONE_BUTTON) + || m.equals(Material.WARPED_BUTTON) || m.equals(Material.TORCH) - || m.equals(B.mat("SOUL_TORCH")); + || m.equals(Material.SOUL_TORCH); //@done } } diff --git a/src/main/java/com/volmit/iris/util/Consumer2.java b/src/main/java/com/volmit/iris/util/Consumer2.java index 541c72d98..cf4739ac4 100644 --- a/src/main/java/com/volmit/iris/util/Consumer2.java +++ b/src/main/java/com/volmit/iris/util/Consumer2.java @@ -1,6 +1,5 @@ package com.volmit.iris.util; -@SuppressWarnings("hiding") @FunctionalInterface public interface Consumer2 { diff --git a/src/main/java/com/volmit/iris/util/Consumer3.java b/src/main/java/com/volmit/iris/util/Consumer3.java index 0df001b3e..0bfe71377 100644 --- a/src/main/java/com/volmit/iris/util/Consumer3.java +++ b/src/main/java/com/volmit/iris/util/Consumer3.java @@ -1,6 +1,5 @@ package com.volmit.iris.util; -@SuppressWarnings("hiding") @FunctionalInterface public interface Consumer3 { diff --git a/src/main/java/com/volmit/iris/util/Function2.java b/src/main/java/com/volmit/iris/util/Function2.java index 238b2c957..e19f63bb2 100644 --- a/src/main/java/com/volmit/iris/util/Function2.java +++ b/src/main/java/com/volmit/iris/util/Function2.java @@ -1,6 +1,5 @@ package com.volmit.iris.util; -@SuppressWarnings("hiding") @FunctionalInterface public interface Function2 { diff --git a/src/main/java/com/volmit/iris/util/Function3.java b/src/main/java/com/volmit/iris/util/Function3.java index bb6e5ab87..df65a6815 100644 --- a/src/main/java/com/volmit/iris/util/Function3.java +++ b/src/main/java/com/volmit/iris/util/Function3.java @@ -1,6 +1,5 @@ package com.volmit.iris.util; -@SuppressWarnings("hiding") @FunctionalInterface public interface Function3 { diff --git a/src/main/java/com/volmit/iris/util/Function4.java b/src/main/java/com/volmit/iris/util/Function4.java index 7026829f2..0dfe18d56 100644 --- a/src/main/java/com/volmit/iris/util/Function4.java +++ b/src/main/java/com/volmit/iris/util/Function4.java @@ -1,6 +1,5 @@ package com.volmit.iris.util; -@SuppressWarnings("hiding") @FunctionalInterface public interface Function4 {