diff --git a/pom.xml b/pom.xml index 4a54ead13..afd84b0ec 100644 --- a/pom.xml +++ b/pom.xml @@ -4,7 +4,7 @@ 4.0.0 bytecode.ninja Iris - 1.0.20 + 1.0.21 Iris false diff --git a/src/main/java/com/volmit/iris/gen/ContextualTerrainProvider.java b/src/main/java/com/volmit/iris/gen/ContextualTerrainProvider.java index 5c1b860b9..566f97e78 100644 --- a/src/main/java/com/volmit/iris/gen/ContextualTerrainProvider.java +++ b/src/main/java/com/volmit/iris/gen/ContextualTerrainProvider.java @@ -89,7 +89,7 @@ public abstract class ContextualTerrainProvider implements TerrainProvider, List tickLatch = new ChronoLatch(650); perSecond = new ChronoLatch(1000); hlast = M.ms(); - cache = new AtomicMulticache((IrisTerrainProvider) this); + cache = new AtomicMulticache((SkyTerrainProvider) this); CNG.creates = 0; generated = 0; ticks = 0; @@ -470,7 +470,6 @@ public abstract class ContextualTerrainProvider implements TerrainProvider, List Iris.instance.imsg(i, C.DARK_RED + "Iris Generator has crashed!"); Iris.instance.imsg(i, C.RED + "- Check the console for the error."); Iris.instance.imsg(i, C.RED + "- To Regen, use /iris std open "); - Iris.instance.imsg(i, C.RED + "- To Retry the chunk, use /iris world retry"); } }); diff --git a/src/main/java/com/volmit/iris/gen/DimensionalTerrainProvider.java b/src/main/java/com/volmit/iris/gen/DimensionalTerrainProvider.java index 9baa4450b..629d6a2d7 100644 --- a/src/main/java/com/volmit/iris/gen/DimensionalTerrainProvider.java +++ b/src/main/java/com/volmit/iris/gen/DimensionalTerrainProvider.java @@ -26,6 +26,7 @@ import lombok.EqualsAndHashCode; public abstract class DimensionalTerrainProvider extends ContextualTerrainProvider { private String dimensionName; + private IrisDimension forceDimension; protected static final FastBlockData AIR = FastBlockData.of(Material.AIR); protected static final FastBlockData CAVE_AIR = B.get("CAVE_AIR"); protected static final FastBlockData BEDROCK = FastBlockData.of(Material.BEDROCK); @@ -35,6 +36,7 @@ public abstract class DimensionalTerrainProvider extends ContextualTerrainProvid { super(t); setDimensionName(dimensionName); + setForceDimension(null); if(getDimensionName().isEmpty()) { @@ -99,6 +101,11 @@ public abstract class DimensionalTerrainProvider extends ContextualTerrainProvid } } + protected void forceDimension(IrisDimension sky) + { + setForceDimension(sky); + } + protected void useDefaultDimensionSetupNOW() { @@ -124,6 +131,11 @@ public abstract class DimensionalTerrainProvider extends ContextualTerrainProvid public IrisDimension getDimension() { + if(forceDimension != null) + { + return forceDimension; + } + IrisDimension d = loadDimension(getDimensionName()); return d; diff --git a/src/main/java/com/volmit/iris/gen/IrisTerrainProvider.java b/src/main/java/com/volmit/iris/gen/IrisTerrainProvider.java index 3833a31ca..ac6f78ed6 100644 --- a/src/main/java/com/volmit/iris/gen/IrisTerrainProvider.java +++ b/src/main/java/com/volmit/iris/gen/IrisTerrainProvider.java @@ -253,6 +253,7 @@ public class IrisTerrainProvider extends SkyTerrainProvider implements IrisConte getData().dump(); getCache().drop(); onHotload(); + skyHotload(); Iris.proj.updateWorkspace(); } diff --git a/src/main/java/com/volmit/iris/gen/SkyTerrainProvider.java b/src/main/java/com/volmit/iris/gen/SkyTerrainProvider.java index e1cd7b983..2d86294be 100644 --- a/src/main/java/com/volmit/iris/gen/SkyTerrainProvider.java +++ b/src/main/java/com/volmit/iris/gen/SkyTerrainProvider.java @@ -1,5 +1,20 @@ package com.volmit.iris.gen; +import java.util.function.Function; + +import org.bukkit.Chunk; +import org.bukkit.Material; +import org.bukkit.block.Biome; +import org.bukkit.block.data.BlockData; +import org.bukkit.entity.Player; +import org.bukkit.event.block.BlockDropItemEvent; +import org.bukkit.event.entity.EntitySpawnEvent; +import org.bukkit.generator.ChunkGenerator.BiomeGrid; +import org.bukkit.generator.ChunkGenerator.ChunkData; +import org.bukkit.material.MaterialData; +import org.bukkit.util.BlockVector; + +import com.volmit.iris.Iris; import com.volmit.iris.gen.scaffold.GeneratedChunk; import com.volmit.iris.gen.scaffold.TerrainChunk; import com.volmit.iris.gen.scaffold.TerrainTarget; @@ -7,14 +22,232 @@ import com.volmit.iris.util.RNG; public abstract class SkyTerrainProvider extends PostBlockTerrainProvider { + private IrisTerrainProvider actualSky; + public SkyTerrainProvider(TerrainTarget t, String dimensionName, int threads) { super(t, dimensionName, threads); } + public void skyHotload() + { + if(actualSky != null) + { + actualSky.onHotloaded(); + } + } + @Override protected GeneratedChunk onGenerate(RNG random, int x, int z, TerrainChunk terrain) { - return super.onGenerate(random, x, z, terrain); + GeneratedChunk gc = super.onGenerate(random, x, z, terrain); + + if(getDimension().hasSky()) + { + getDimension().getSky().setSkyDimension(true); + if(actualSky == null) + { + actualSky = new IrisTerrainProvider(getTarget(), "...", getThreads()) + { + @Override + public boolean shouldGenerateVanillaStructures() + { + return false; + } + + @Override + public boolean shouldGenerateMobs() + { + return false; + } + + @Override + public boolean shouldGenerateDecorations() + { + return false; + } + + @Override + public boolean shouldGenerateCaves() + { + return getDimension().getSky().isVanillaCaves(); + } + + @Override + public BlockVector computeSpawn(Function allowed) + { + return null; + } + + @Override + public boolean canSpawn(int x, int z) + { + return false; + } + + @Override + protected void onSpawn(EntitySpawnEvent e) + { + + } + + @Override + protected void onPlayerJoin(Player p) + { + + } + + @Override + protected void onFailure(Throwable e) + { + + } + + @Override + protected void onChunkUnloaded(Chunk c) + { + + } + + @Override + protected void onChunkLoaded(Chunk c) + { + + } + + @Override + protected void handleDrops(BlockDropItemEvent e) + { + + } + }; + + actualSky.changeThreadCount(getThreads()); + actualSky.forceDimension(getDimension().getSky()); + actualSky.setMasterRandom(new RNG(getMasterRandom().nextParallelRNG(299455).nextLong())); + Iris.info("Created Sky Dimension Provider"); + } + + try + { + actualSky.onGenerate(random, x, z, new TerrainChunk() + { + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, BlockData blockData) + { + + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, MaterialData material) + { + + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, Material material) + { + + } + + @Override + public void setBlock(int x, int y, int z, MaterialData material) + { + gc.getTerrain().setBlock(x, 255 - y, z, material); + } + + @Override + public void setBlock(int x, int y, int z, Material material) + { + gc.getTerrain().setBlock(x, 255 - y, z, material); + } + + @Override + public MaterialData getTypeAndData(int x, int y, int z) + { + return gc.getTerrain().getTypeAndData(x, 255 - y, z); + } + + @Override + public Material getType(int x, int y, int z) + { + return gc.getTerrain().getType(x, 255 - y, z); + } + + @Override + public byte getData(int x, int y, int z) + { + return 0; + } + + @Override + public void setRaw(ChunkData data) + { + + } + + @Override + public void setBlock(int x, int y, int z, BlockData blockData) + { + gc.getTerrain().setBlock(x, 255 - y, z, blockData); + } + + @Override + public void setBiome(int x, int y, int z, Biome bio) + { + gc.getTerrain().setBiome(x, 255 - y, z, bio); + } + + @Override + public void setBiome(int x, int z, Biome bio) + { + + } + + @Override + public void inject(BiomeGrid biome) + { + + } + + @Override + public ChunkData getRaw() + { + return null; + } + + @Override + public int getMaxHeight() + { + return gc.getTerrain().getMaxHeight(); + } + + @Override + public BlockData getBlockData(int x, int y, int z) + { + return gc.getTerrain().getBlockData(x, 255 - y, z); + } + + @Override + public Biome getBiome(int x, int y, int z) + { + return gc.getTerrain().getBiome(x, 255 - y, z); + } + + @Override + public Biome getBiome(int x, int z) + { + return Biome.THE_VOID; + } + }); + } + + catch(Throwable e) + { + + } + } + + return gc; } } diff --git a/src/main/java/com/volmit/iris/gen/atomics/AtomicMulticache.java b/src/main/java/com/volmit/iris/gen/atomics/AtomicMulticache.java index 90bf27ffe..ef7b05af0 100644 --- a/src/main/java/com/volmit/iris/gen/atomics/AtomicMulticache.java +++ b/src/main/java/com/volmit/iris/gen/atomics/AtomicMulticache.java @@ -3,7 +3,7 @@ package com.volmit.iris.gen.atomics; import com.github.benmanes.caffeine.cache.Caffeine; import com.github.benmanes.caffeine.cache.LoadingCache; import com.volmit.iris.IrisSettings; -import com.volmit.iris.gen.IrisTerrainProvider; +import com.volmit.iris.gen.SkyTerrainProvider; import com.volmit.iris.object.IrisBiome; import com.volmit.iris.object.IrisRegion; import com.volmit.iris.util.ChunkPosition; @@ -18,7 +18,7 @@ public class AtomicMulticache private final LoadingCache rawBiome; private final LoadingCache region; - public AtomicMulticache(IrisTerrainProvider gen) + public AtomicMulticache(SkyTerrainProvider gen) { height = Caffeine.newBuilder().maximumSize(getLimit()).build((c) -> gen.getNoiseHeight(c.getX(), c.getZ()) + gen.getFluidHeight()); carvedHeight = Caffeine.newBuilder().maximumSize(getLimit()).build((c) -> diff --git a/src/main/java/com/volmit/iris/gen/nms/v16_2/NMSChunkGenerator16_2_PAPER.java b/src/main/java/com/volmit/iris/gen/nms/v16_2/NMSChunkGenerator16_2_PAPER.java index 5d57d40f6..bc67f870a 100644 --- a/src/main/java/com/volmit/iris/gen/nms/v16_2/NMSChunkGenerator16_2_PAPER.java +++ b/src/main/java/com/volmit/iris/gen/nms/v16_2/NMSChunkGenerator16_2_PAPER.java @@ -418,12 +418,20 @@ public class NMSChunkGenerator16_2_PAPER extends ChunkGenerator implements Provi { for(int zz = 0; zz < 16; zz++) { - int y = gc.getHeight().getHeight(xx, zz); - if(y < getSeaLevel()) + try { - heightmap.a(xx, y, zz, Blocks.STONE.getBlockData()); + int y = gc.getHeight().getHeight(xx, zz); + if(y < getSeaLevel()) + { + heightmap.a(xx, y, zz, Blocks.STONE.getBlockData()); + } + heightmap1.a(xx, Math.max(y, getSeaLevel()), zz, Blocks.STONE.getBlockData()); + } + + catch(Throwable e) + { + } - heightmap1.a(xx, Math.max(y, getSeaLevel()), zz, Blocks.STONE.getBlockData()); } } } diff --git a/src/main/java/com/volmit/iris/generator/IrisTerrainProvider.java b/src/main/java/com/volmit/iris/generator/IrisTerrainProvider.java new file mode 100644 index 000000000..5d15576d9 --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/IrisTerrainProvider.java @@ -0,0 +1,6 @@ +package com.volmit.iris.generator; + +public class IrisTerrainProvider +{ + +} diff --git a/src/main/java/com/volmit/iris/generator/atomics/Hunk.java b/src/main/java/com/volmit/iris/generator/atomics/Hunk.java new file mode 100644 index 000000000..bf8a20006 --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/atomics/Hunk.java @@ -0,0 +1,218 @@ +package com.volmit.iris.generator.atomics; + +import org.bouncycastle.util.Arrays; + +import lombok.Data; + +@Data +public class Hunk +{ + protected final int w; + protected final int h; + protected final int d; + protected final T[] data; + + @SuppressWarnings("unchecked") + public Hunk(int w, int h, int d) + { + this.w = w; + this.h = h; + this.d = d; + data = (T[]) new Object[w * h * d]; + } + + /** + * Create a new hunk from a section of this hunk. + * + * + * @param x1 + * The min x (inclusive) + * @param y1 + * The min y (inclusive) + * @param z1 + * The min z (inclusive) + * @param x2 + * The max x (exclusive) + * @param y2 + * The max y (exclusive) + * @param z2 + * The max z (exclusive) + * @return the new hunk (x2-x1, y2-y1, z2-z1) + */ + public Hunk crop(int x1, int y1, int z1, int x2, int y2, int z2) + { + Hunk h = new Hunk(x2 - x1, y2 - y1, z2 - z1); + + for(int i = x1; i < x2; i++) + { + for(int j = y1; j < y2; j++) + { + for(int k = z1; k < z2; k++) + { + h.set(i - x1, j - y1, k - z1, get(i, j, k)); + } + } + } + + return h; + } + + /** + * Insert a hunk into this one with an offset the inserted hunk + * + * @param offX + * the offset from zero for x + * @param offY + * the offset from zero for y + * @param offZ + * the offset from zero for z + * @param hunk + * the hunk to insert + */ + public void insert(int offX, int offY, int offZ, Hunk hunk) + { + insert(offX, offY, offZ, hunk, false); + } + + /** + * Insert a hunk into this one + * + * @param hunk + * the hunk to insert + */ + public void insert(Hunk hunk) + { + insert(0, 0, 0, hunk, false); + } + + /** + * Insert a hunk into this one + * + * @param hunk + * the hunk to insert + * @param inverted + * invert the inserted hunk or not + */ + public void insert(Hunk hunk, boolean inverted) + { + insert(0, 0, 0, hunk, inverted); + } + + /** + * Insert a hunk into this one with an offset and possibly inverting the y of + * the inserted hunk + * + * @param offX + * the offset from zero for x + * @param offY + * the offset from zero for y + * @param offZ + * the offset from zero for z + * @param hunk + * the hunk to insert + * @param invertY + * should the inserted hunk be inverted + */ + public void insert(int offX, int offY, int offZ, Hunk hunk, boolean invertY) + { + if(offX + (hunk.getW() - 1) >= w || offY + (hunk.getH() - 1) >= h || offZ + (hunk.getD() - 1) >= d || offX < 0 || offY < 0 || offZ < 0) + { + throw new RuntimeException("Cannot insert hunk " + hunk.getW() + "," + hunk.getH() + "," + hunk.getD() + " into Hunk " + w + "," + h + "," + d + " with offset " + offZ + "," + offY + "," + offZ); + } + + for(int i = offX; i < offX + hunk.getW(); i++) + { + for(int j = offY; j < offY + hunk.getH(); j++) + { + for(int k = offZ; k < offZ + hunk.getD(); k++) + { + set(i, j, k, hunk.get(i - offX, j - offY, k - offZ)); + } + } + } + } + + public void set(int x, int y, int z, T t) + { + data[index(x, y, z)] = t; + } + + public T get(int x, int y, int z) + { + return data[index(x, y, z)]; + } + + public void setInvertedY(int x, int y, int z, T t) + { + data[index(x, h - y, z)] = t; + } + + public T getInvertedY(int x, int y, int z) + { + return data[index(x, h - y, z)]; + } + + protected int index(int x, int y, int z) + { + if(x >= w || y >= h || z >= d) + { + throw new RuntimeException(x + " " + y + " " + z + " is out of the bounds 0,0,0 - " + (w - 1) + "," + (h - 1) + "," + (d - 1)); + } + + return (z * w * h) + (y * w) + x; + } + + public void fill(T t) + { + Arrays.fill(data, t); + } + + @SafeVarargs + public static Hunk combined(T defaultNode, Hunk... hunks) + { + int w = 0; + int h = 0; + int d = 0; + + for(Hunk i : hunks) + { + w = Math.max(w, i.getW()); + h = Math.max(h, i.getH()); + d = Math.max(d, i.getD()); + } + + Hunk b = new Hunk(w, h, d); + b.fill(defaultNode); + + for(Hunk i : hunks) + { + b.insert(i); + } + + return b; + } + + @SafeVarargs + public static Hunk combined(Hunk... hunks) + { + int w = 0; + int h = 0; + int d = 0; + + for(Hunk i : hunks) + { + w = Math.max(w, i.getW()); + h = Math.max(h, i.getH()); + d = Math.max(d, i.getD()); + } + + Hunk b = new Hunk(w, h, d); + + for(Hunk i : hunks) + { + b.insert(i); + } + + return b; + } +} diff --git a/src/main/java/com/volmit/iris/generator/atomics/TerrainHunk.java b/src/main/java/com/volmit/iris/generator/atomics/TerrainHunk.java new file mode 100644 index 000000000..fcc352d40 --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/atomics/TerrainHunk.java @@ -0,0 +1,204 @@ +package com.volmit.iris.generator.atomics; + +import org.bukkit.Material; +import org.bukkit.block.Biome; +import org.bukkit.block.data.BlockData; +import org.bukkit.generator.ChunkGenerator.BiomeGrid; +import org.bukkit.generator.ChunkGenerator.ChunkData; +import org.bukkit.material.MaterialData; + +@SuppressWarnings("deprecation") +public class TerrainHunk extends Hunk implements BiomeGrid, ChunkData +{ + public TerrainHunk(int w, int h, int d) + { + super(w, h, d); + } + + @Override + public int getMaxHeight() + { + return getH(); + } + + private void set(int x, int y, int z, BlockData block) + { + TerrainNode n = get(x, y, z); + + if(n == null) + { + n = new TerrainNode(Biome.THE_VOID, block); + } + + else + { + n = n.setBlockData(block); + } + + set(x, y, z, n); + } + + private void set(int x, int y, int z, Biome biome) + { + TerrainNode n = get(x, y, z); + + if(n == null) + { + n = new TerrainNode(biome, Material.AIR.createBlockData()); + } + + else + { + n = n.setBiome(biome); + } + + set(x, y, z, n); + } + + @Override + public void setBlock(int x, int y, int z, Material material) + { + set(x, y, z, material.createBlockData()); + } + + @Override + public void setBlock(int x, int y, int z, MaterialData material) + { + set(x, y, z, material.getItemType().createBlockData()); + } + + @Override + public void setBlock(int x, int y, int z, BlockData blockData) + { + set(x, y, z, blockData); + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, Material material) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, MaterialData material) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public void setRegion(int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, BlockData blockData) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public Material getType(int x, int y, int z) + { + return getBlockData(x, y, z).getMaterial(); + } + + @Override + public MaterialData getTypeAndData(int x, int y, int z) + { + return new MaterialData(getBlockData(x, y, z).getMaterial()); + } + + @Override + public BlockData getBlockData(int x, int y, int z) + { + TerrainNode n = get(x, y, z); + + if(n == null) + { + return Material.STONE.createBlockData(); + } + + return n.getBlockData(); + } + + @Override + public byte getData(int x, int y, int z) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public Biome getBiome(int x, int z) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public Biome getBiome(int x, int y, int z) + { + TerrainNode n = get(x, y, z); + + if(n == null) + { + return Biome.THE_VOID; + } + + return n.getBiome(); + } + + @Override + public void setBiome(int x, int z, Biome bio) + { + throw new RuntimeException("Not Supported"); + } + + @Override + public void setBiome(int x, int y, int z, Biome bio) + { + set(x, y, z, bio); + } + + @SafeVarargs + public static TerrainHunk combined(TerrainNode defaultNode, TerrainHunk... hunks) + { + int w = 0; + int h = 0; + int d = 0; + + for(TerrainHunk i : hunks) + { + w = Math.max(w, i.getW()); + h = Math.max(h, i.getH()); + d = Math.max(d, i.getD()); + } + + TerrainHunk b = new TerrainHunk(w, h, d); + b.fill(defaultNode); + + for(TerrainHunk i : hunks) + { + b.insert(i); + } + + return b; + } + + @SafeVarargs + public static TerrainHunk combined(TerrainHunk... hunks) + { + int w = 0; + int h = 0; + int d = 0; + + for(TerrainHunk i : hunks) + { + w = Math.max(w, i.getW()); + h = Math.max(h, i.getH()); + d = Math.max(d, i.getD()); + } + + TerrainHunk b = new TerrainHunk(w, h, d); + + for(TerrainHunk i : hunks) + { + b.insert(i); + } + + return b; + } +} diff --git a/src/main/java/com/volmit/iris/generator/atomics/TerrainNode.java b/src/main/java/com/volmit/iris/generator/atomics/TerrainNode.java new file mode 100644 index 000000000..908811fcf --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/atomics/TerrainNode.java @@ -0,0 +1,61 @@ +package com.volmit.iris.generator.atomics; + +import org.bukkit.block.Biome; +import org.bukkit.block.data.BlockData; + +import com.volmit.iris.util.KList; + +public class TerrainNode +{ + private static final KList blockDataPalette = new KList(); + + private final byte biome; + private final short block; + + private TerrainNode(byte biome, short block) + { + this.biome = biome; + this.block = block; + } + + public TerrainNode(Biome biome, BlockData block) + { + this((byte) (biome.ordinal() + Byte.MIN_VALUE), (short) (paletteOf(block) + Short.MIN_VALUE)); + } + + public TerrainNode setBlockData(BlockData block) + { + return new TerrainNode(biome, (short) (paletteOf(block) + Short.MIN_VALUE)); + } + + public TerrainNode setBiome(Biome biome) + { + return new TerrainNode((byte) (biome.ordinal() + Byte.MIN_VALUE), block); + } + + public BlockData getBlockData() + { + return blockDataPalette.get(block); + } + + public Biome getBiome() + { + return Biome.values()[biome]; + } + + private static int paletteOf(BlockData b) + { + synchronized(blockDataPalette) + { + int v = blockDataPalette.indexOf(b); + + if(v >= 0) + { + return v; + } + + blockDataPalette.add(b); + return blockDataPalette.size() - 1; + } + } +} diff --git a/src/main/java/com/volmit/iris/generator/scaffold/IrisTerrainStream.java b/src/main/java/com/volmit/iris/generator/scaffold/IrisTerrainStream.java new file mode 100644 index 000000000..b63b95590 --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/scaffold/IrisTerrainStream.java @@ -0,0 +1,18 @@ +package com.volmit.iris.generator.scaffold; + +import com.volmit.iris.generator.atomics.TerrainHunk; + +public class IrisTerrainStream implements TerrainStream +{ + @Override + public TerrainHunk generate(int x1, int z1, int x2, int z2) + { + return null; + } + + @Override + public TerrainHunk generate(int x, int z) + { + return null; + } +} diff --git a/src/main/java/com/volmit/iris/generator/scaffold/TerrainStream.java b/src/main/java/com/volmit/iris/generator/scaffold/TerrainStream.java new file mode 100644 index 000000000..90794cbe4 --- /dev/null +++ b/src/main/java/com/volmit/iris/generator/scaffold/TerrainStream.java @@ -0,0 +1,10 @@ +package com.volmit.iris.generator.scaffold; + +import com.volmit.iris.generator.atomics.TerrainHunk; + +public interface TerrainStream +{ + public TerrainHunk generate(int x1, int z1, int x2, int z2); + + public TerrainHunk generate(int x, int z); +} diff --git a/src/main/java/com/volmit/iris/manager/IrisProject.java b/src/main/java/com/volmit/iris/manager/IrisProject.java index 31d93ba4d..d72a26fde 100644 --- a/src/main/java/com/volmit/iris/manager/IrisProject.java +++ b/src/main/java/com/volmit/iris/manager/IrisProject.java @@ -238,7 +238,7 @@ public class IrisProject return new File(path, getName() + ".code-workspace"); } - public void updateWorkspace() + public boolean updateWorkspace() { getPath().mkdirs(); File ws = getCodeWorkspaceFile(); @@ -251,6 +251,7 @@ public class IrisProject IO.writeAll(ws, j.toString(4)); p.end(); Iris.info("Updated Workspace: " + ws.getPath() + " in " + Form.duration(p.getMilliseconds(), 2)); + return true; } catch(Throwable e) @@ -267,6 +268,8 @@ public class IrisProject e1.printStackTrace(); } } + + return false; } public JSONObject createCodeWorkspaceConfig() diff --git a/src/main/java/com/volmit/iris/manager/ProjectManager.java b/src/main/java/com/volmit/iris/manager/ProjectManager.java index 6850c6037..3cc9d36f3 100644 --- a/src/main/java/com/volmit/iris/manager/ProjectManager.java +++ b/src/main/java/com/volmit/iris/manager/ProjectManager.java @@ -91,7 +91,7 @@ public class ProjectManager catch(IOException e) { - e.printStackTrace(); + } } diff --git a/src/main/java/com/volmit/iris/manager/WandManager.java b/src/main/java/com/volmit/iris/manager/WandManager.java index b84f703ba..4fe43d67e 100644 --- a/src/main/java/com/volmit/iris/manager/WandManager.java +++ b/src/main/java/com/volmit/iris/manager/WandManager.java @@ -155,24 +155,32 @@ public class WandManager implements Listener @EventHandler public void on(PlayerInteractEvent e) { - if(e.getHand().equals(EquipmentSlot.HAND) && isWand(e.getPlayer().getInventory().getItemInMainHand())) + try { - if(e.getAction().equals(Action.LEFT_CLICK_BLOCK)) + if(e.getHand().equals(EquipmentSlot.HAND) && isWand(e.getPlayer().getInventory().getItemInMainHand())) { - e.setCancelled(true); - e.getPlayer().getInventory().setItemInMainHand(update(true, e.getClickedBlock().getLocation(), e.getPlayer().getInventory().getItemInMainHand())); - e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 0.67f); - e.getPlayer().updateInventory(); - } + if(e.getAction().equals(Action.LEFT_CLICK_BLOCK)) + { + e.setCancelled(true); + e.getPlayer().getInventory().setItemInMainHand(update(true, e.getClickedBlock().getLocation(), e.getPlayer().getInventory().getItemInMainHand())); + e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 0.67f); + e.getPlayer().updateInventory(); + } - else if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) - { - e.setCancelled(true); - e.getPlayer().getInventory().setItemInMainHand(update(false, e.getClickedBlock().getLocation(), e.getPlayer().getInventory().getItemInMainHand())); - e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 1.17f); - e.getPlayer().updateInventory(); + else if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) + { + e.setCancelled(true); + e.getPlayer().getInventory().setItemInMainHand(update(false, e.getClickedBlock().getLocation(), e.getPlayer().getInventory().getItemInMainHand())); + e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 1.17f); + e.getPlayer().updateInventory(); + } } } + + catch(Throwable ex) + { + + } } public static void pasteSchematic(IrisObject s, Location at) diff --git a/src/main/java/com/volmit/iris/object/IrisCaveFluid.java b/src/main/java/com/volmit/iris/object/IrisCaveFluid.java index b3c825a8a..4bb31d28d 100644 --- a/src/main/java/com/volmit/iris/object/IrisCaveFluid.java +++ b/src/main/java/com/volmit/iris/object/IrisCaveFluid.java @@ -26,7 +26,7 @@ public class IrisCaveFluid @MaxNumber(255) @MinNumber(0) @DontObfuscate - @Desc("The cave zoom. Higher values makes caves spread out further and branch less often, but are thicker.") + @Desc("The fluid height of the cave") private int fluidHeight = 35; @DontObfuscate