From cd07f2903874186a85bf3bace7593a29e985c61e Mon Sep 17 00:00:00 2001 From: Daniel Mills Date: Wed, 5 Aug 2020 02:56:18 -0400 Subject: [PATCH] Loads of fixes --- .../java/com/volmit/iris/IrisDataManager.java | 3 + .../iris/command/CommandIrisObjectPaste.java | 6 +- .../iris/command/CommandIrisPregen.java | 60 ++++++ .../volmit/iris/command/CommandIrisWorld.java | 3 + .../iris/gen/ParallaxChunkGenerator.java | 15 ++ .../iris/gen/TerrainChunkGenerator.java | 4 +- .../iris/gen/layer/BiomeDataProvider.java | 6 +- .../volmit/iris/gen/layer/GenLayerBiome.java | 12 +- .../iris/object/IrisAxisRotationClamp.java | 7 +- .../com/volmit/iris/object/IrisBiome.java | 12 +- .../iris/object/IrisCompatabilityFilter.java | 54 +++++ .../com/volmit/iris/object/IrisDimension.java | 110 +++++++++++ .../com/volmit/iris/object/IrisObject.java | 21 ++ .../iris/object/IrisObjectPlacement.java | 8 + .../com/volmit/iris/object/IrisRegion.java | 4 + .../volmit/iris/object/IrisRegistrant.java | 4 +- .../com/volmit/iris/object/IrisStructure.java | 163 +++++++++++++++ .../iris/object/IrisStructurePlacement.java | 134 +++++++++++++ .../volmit/iris/object/IrisStructureTile.java | 95 +++++++++ .../iris/object/StructureTileCondition.java | 25 +++ .../volmit/iris/object/StructureTileFace.java | 28 +++ .../com/volmit/iris/object/TileResult.java | 21 ++ .../com/volmit/iris/util/CellGenerator.java | 26 ++- .../java/com/volmit/iris/util/PregenJob.java | 186 ++++++++++++++++++ ...enerator.java => RarityCellGenerator.java} | 4 +- 25 files changed, 987 insertions(+), 24 deletions(-) create mode 100644 src/main/java/com/volmit/iris/command/CommandIrisPregen.java create mode 100644 src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java create mode 100644 src/main/java/com/volmit/iris/object/IrisStructure.java create mode 100644 src/main/java/com/volmit/iris/object/IrisStructurePlacement.java create mode 100644 src/main/java/com/volmit/iris/object/IrisStructureTile.java create mode 100644 src/main/java/com/volmit/iris/object/StructureTileCondition.java create mode 100644 src/main/java/com/volmit/iris/object/StructureTileFace.java create mode 100644 src/main/java/com/volmit/iris/object/TileResult.java create mode 100644 src/main/java/com/volmit/iris/util/PregenJob.java rename src/main/java/com/volmit/iris/util/{BiomeRarityCellGenerator.java => RarityCellGenerator.java} (89%) diff --git a/src/main/java/com/volmit/iris/IrisDataManager.java b/src/main/java/com/volmit/iris/IrisDataManager.java index 454f4db3c..a04c14da6 100644 --- a/src/main/java/com/volmit/iris/IrisDataManager.java +++ b/src/main/java/com/volmit/iris/IrisDataManager.java @@ -13,6 +13,7 @@ import com.volmit.iris.object.IrisGenerator; import com.volmit.iris.object.IrisNoiseGenerator; import com.volmit.iris.object.IrisObjectPlacement; import com.volmit.iris.object.IrisRegion; +import com.volmit.iris.object.IrisStructure; import com.volmit.iris.util.IO; import com.volmit.iris.util.JSONObject; import com.volmit.iris.util.ObjectResourceLoader; @@ -29,6 +30,7 @@ public class IrisDataManager private ResourceLoader regionLoader; private ResourceLoader dimensionLoader; private ResourceLoader generatorLoader; + private ResourceLoader structureLoader; private ObjectResourceLoader objectLoader; public void hotloaded() @@ -37,6 +39,7 @@ public class IrisDataManager this.regionLoader = new ResourceLoader<>(packs, "regions", "Region", IrisRegion.class); this.biomeLoader = new ResourceLoader<>(packs, "biomes", "Biome", IrisBiome.class); this.dimensionLoader = new ResourceLoader<>(packs, "dimensions", "Dimension", IrisDimension.class); + this.structureLoader = new ResourceLoader<>(packs, "structures", "Structure", IrisStructure.class); this.generatorLoader = new ResourceLoader<>(packs, "generators", "Generator", IrisGenerator.class); this.objectLoader = new ObjectResourceLoader(packs, "objects", "Object"); writeExamples(); diff --git a/src/main/java/com/volmit/iris/command/CommandIrisObjectPaste.java b/src/main/java/com/volmit/iris/command/CommandIrisObjectPaste.java index b68b7773f..7c54429ed 100644 --- a/src/main/java/com/volmit/iris/command/CommandIrisObjectPaste.java +++ b/src/main/java/com/volmit/iris/command/CommandIrisObjectPaste.java @@ -52,7 +52,7 @@ public class CommandIrisObjectPaste extends MortarCommand sender.sendMessage("Can't find " + "objects/" + args[0] + ".iob"); } - ItemStack wand = ((Player) sender).getInventory().getItemInMainHand(); + ItemStack wand = sender.player().getInventory().getItemInMainHand(); IrisObject o = new IrisObject(0, 0, 0); try @@ -60,8 +60,8 @@ public class CommandIrisObjectPaste extends MortarCommand o.read(new File(Iris.instance.getDataFolder(), "objects/" + args[0] + ".iob")); sender.sendMessage("Loaded " + "objects/" + args[0] + ".iob"); - ((Player) sender).getWorld().playSound(((Player) sender).getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f); - Location block = ((Player) sender).getTargetBlock((Set) null, 256).getLocation().clone().add(0, 1, 0); + sender.player().getWorld().playSound(sender.player().getLocation(), Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f); + Location block = sender.player().getTargetBlock((Set) null, 256).getLocation().clone().add(0, 1, 0); if(intoWand && WandController.isWand(wand)) { diff --git a/src/main/java/com/volmit/iris/command/CommandIrisPregen.java b/src/main/java/com/volmit/iris/command/CommandIrisPregen.java new file mode 100644 index 000000000..29a99f857 --- /dev/null +++ b/src/main/java/com/volmit/iris/command/CommandIrisPregen.java @@ -0,0 +1,60 @@ +package com.volmit.iris.command; + +import org.bukkit.World; +import org.bukkit.entity.Player; + +import com.volmit.iris.Iris; +import com.volmit.iris.util.MortarCommand; +import com.volmit.iris.util.MortarSender; +import com.volmit.iris.util.PregenJob; + +public class CommandIrisPregen extends MortarCommand +{ + public CommandIrisPregen() + { + super("pregen"); + setDescription("Pregen this world"); + requiresPermission(Iris.perm.studio); + setCategory("Pregen"); + } + + @Override + public boolean handle(MortarSender sender, String[] args) + { + if(args[0].equalsIgnoreCase("stop")) + { + if(PregenJob.task == -1) + { + sender.sendMessage("No Active Pregens"); + } + else + { + sender.sendMessage("Stopped all pregens."); + } + PregenJob.stop(); + return true; + } + + if(sender.isPlayer()) + { + Player p = sender.player(); + World world = p.getWorld(); + new PregenJob(world, Integer.valueOf(args[0])); + + return true; + } + + else + { + sender.sendMessage("Players only."); + } + + return true; + } + + @Override + protected String getArgsUsage() + { + return "[width]"; + } +} diff --git a/src/main/java/com/volmit/iris/command/CommandIrisWorld.java b/src/main/java/com/volmit/iris/command/CommandIrisWorld.java index b70d1080e..6ddbc9e43 100644 --- a/src/main/java/com/volmit/iris/command/CommandIrisWorld.java +++ b/src/main/java/com/volmit/iris/command/CommandIrisWorld.java @@ -13,6 +13,9 @@ public class CommandIrisWorld extends MortarCommand @Command private CommandIrisMetrics metrics; + @Command + private CommandIrisPregen pregen; + public CommandIrisWorld() { super("world", "wrld"); diff --git a/src/main/java/com/volmit/iris/gen/ParallaxChunkGenerator.java b/src/main/java/com/volmit/iris/gen/ParallaxChunkGenerator.java index 99fd4b7d9..f5f062255 100644 --- a/src/main/java/com/volmit/iris/gen/ParallaxChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/ParallaxChunkGenerator.java @@ -13,6 +13,8 @@ import com.volmit.iris.gen.atomics.MasterLock; import com.volmit.iris.object.IrisBiome; import com.volmit.iris.object.IrisBiomeMutation; import com.volmit.iris.object.IrisObjectPlacement; +import com.volmit.iris.object.IrisRegion; +import com.volmit.iris.object.IrisStructurePlacement; import com.volmit.iris.util.BiomeMap; import com.volmit.iris.util.CaveResult; import com.volmit.iris.util.ChunkPosition; @@ -220,6 +222,7 @@ public abstract class ParallaxChunkGenerator extends TerrainChunkGenerator imple getAccelerant().queue(key, () -> { IrisBiome b = sampleTrueBiome((i * 16) + 7, (j * 16) + 7).getBiome(); + RNG ro = random.nextParallelRNG(496888 + i + j); int g = 1; @@ -254,6 +257,18 @@ public abstract class ParallaxChunkGenerator extends TerrainChunkGenerator imple } } + IrisRegion r = sampleRegion((i * 16) + 7, (j * 16) + 7); + + for(IrisStructurePlacement k : r.getStructures()) + { + k.place(this, random, i, j); + } + + for(IrisStructurePlacement k : b.getStructures()) + { + k.place(this, random, i, j); + } + for(IrisObjectPlacement k : b.getObjects()) { int gg = g++; diff --git a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java index f7de9277e..be81cd41d 100644 --- a/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java +++ b/src/main/java/com/volmit/iris/gen/TerrainChunkGenerator.java @@ -132,9 +132,9 @@ public abstract class TerrainChunkGenerator extends ParallelChunkGenerator } } - for(int k = Math.max(height, fluidHeight); k < Math.max(height, fluidHeight) + 3 + Math.abs(airReversal); k++) + for(int k = Math.max(height, fluidHeight); k < Math.max(height, fluidHeight) + 12 + Math.abs(airReversal); k++) { - if(k < Math.max(height, fluidHeight) + 3) + if(k < Math.max(height, fluidHeight) + 12) { if(biomeMap != null) { diff --git a/src/main/java/com/volmit/iris/gen/layer/BiomeDataProvider.java b/src/main/java/com/volmit/iris/gen/layer/BiomeDataProvider.java index e2557bfc5..52cb340e1 100644 --- a/src/main/java/com/volmit/iris/gen/layer/BiomeDataProvider.java +++ b/src/main/java/com/volmit/iris/gen/layer/BiomeDataProvider.java @@ -2,7 +2,7 @@ package com.volmit.iris.gen.layer; import com.volmit.iris.object.InferredType; import com.volmit.iris.object.IrisRegion; -import com.volmit.iris.util.BiomeRarityCellGenerator; +import com.volmit.iris.util.RarityCellGenerator; import com.volmit.iris.util.BiomeResult; import com.volmit.iris.util.RNG; @@ -12,14 +12,14 @@ import lombok.Data; public class BiomeDataProvider { private InferredType type; - private BiomeRarityCellGenerator generator; + private RarityCellGenerator generator; private GenLayerBiome layer; public BiomeDataProvider(GenLayerBiome layer, InferredType type, RNG rng) { this.type = type; this.layer = layer; - generator = new BiomeRarityCellGenerator(rng.nextParallelRNG(4645079 + (type.ordinal() * 23845))); + generator = new RarityCellGenerator(rng.nextParallelRNG(4645079 + (type.ordinal() * 23845))); } public BiomeResult generatePureData(double bx, double bz, int rawX, int rawZ, IrisRegion regionData) diff --git a/src/main/java/com/volmit/iris/gen/layer/GenLayerBiome.java b/src/main/java/com/volmit/iris/gen/layer/GenLayerBiome.java index 55d874756..af7882243 100644 --- a/src/main/java/com/volmit/iris/gen/layer/GenLayerBiome.java +++ b/src/main/java/com/volmit/iris/gen/layer/GenLayerBiome.java @@ -7,7 +7,7 @@ import com.volmit.iris.object.IrisBiome; import com.volmit.iris.object.IrisRegion; import com.volmit.iris.object.IrisRegionRidge; import com.volmit.iris.object.IrisRegionSpot; -import com.volmit.iris.util.BiomeRarityCellGenerator; +import com.volmit.iris.util.RarityCellGenerator; import com.volmit.iris.util.BiomeResult; import com.volmit.iris.util.CellGenerator; import com.volmit.iris.util.GenLayer; @@ -123,10 +123,10 @@ public class GenLayerBiome extends GenLayer bridgeGenerator.setCellScale(0.33 / iris.getDimension().getContinentZoom()); double x = bx / iris.getDimension().getBiomeZoom(); double z = bz / iris.getDimension().getBiomeZoom(); - return bridgeGenerator.getIndex(x, z, 5) == 1 ? InferredType.SEA : InferredType.LAND; + return bridgeGenerator.getIndex(x, z, 2) == 1 ? InferredType.SEA : InferredType.LAND; } - public BiomeResult generateBiomeData(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator cell, KList biomes, InferredType inferredType) + public BiomeResult generateBiomeData(double bx, double bz, IrisRegion regionData, RarityCellGenerator cell, KList biomes, InferredType inferredType) { if(biomes.isEmpty()) { @@ -162,12 +162,12 @@ public class GenLayerBiome extends GenLayer return pureResult; } - public BiomeResult implode(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator parentCell, BiomeResult parent) + public BiomeResult implode(double bx, double bz, IrisRegion regionData, RarityCellGenerator parentCell, BiomeResult parent) { return implode(bx, bz, regionData, parentCell, parent, 1); } - public BiomeResult implode(double bx, double bz, IrisRegion regionData, BiomeRarityCellGenerator parentCell, BiomeResult parent, int hits) + public BiomeResult implode(double bx, double bz, IrisRegion regionData, RarityCellGenerator parentCell, BiomeResult parent, int hits) { if(hits > 9) { @@ -181,7 +181,7 @@ public class GenLayerBiome extends GenLayer { if(!parent.getBiome().getRealChildren().isEmpty()) { - BiomeRarityCellGenerator childCell = parent.getBiome().getChildrenGenerator(rng, 123, parentCell.getCellScale() * parent.getBiome().getChildShrinkFactor()); + RarityCellGenerator childCell = parent.getBiome().getChildrenGenerator(rng, 123, parentCell.getCellScale() * parent.getBiome().getChildShrinkFactor()); KList chx = parent.getBiome().getRealChildren().copy(); chx.add(parent.getBiome()); IrisBiome biome = childCell.get(x, z, chx); diff --git a/src/main/java/com/volmit/iris/object/IrisAxisRotationClamp.java b/src/main/java/com/volmit/iris/object/IrisAxisRotationClamp.java index 11608b33c..6acd0f58d 100644 --- a/src/main/java/com/volmit/iris/object/IrisAxisRotationClamp.java +++ b/src/main/java/com/volmit/iris/object/IrisAxisRotationClamp.java @@ -41,7 +41,7 @@ public class IrisAxisRotationClamp public boolean isUnlimited() { - return min == max; + return min == max && min == 0; } public double getRadians(int rng) @@ -56,6 +56,11 @@ public class IrisAxisRotationClamp return Math.toRadians(((double) interval * (Math.ceil(Math.abs((rng % 360D) / (double) interval)))) % 360D); } + if(min == max && min != 0) + { + return Math.toRadians(max); + } + return Math.toRadians(M.clip(((double) interval * (Math.ceil(Math.abs((rng % 360D) / (double) interval)))) % 360D, Math.min(min, max), Math.max(min, max))); } } diff --git a/src/main/java/com/volmit/iris/object/IrisBiome.java b/src/main/java/com/volmit/iris/object/IrisBiome.java index 0e51c35b5..d3bcbbaa7 100644 --- a/src/main/java/com/volmit/iris/object/IrisBiome.java +++ b/src/main/java/com/volmit/iris/object/IrisBiome.java @@ -5,7 +5,7 @@ import org.bukkit.block.data.BlockData; import com.volmit.iris.Iris; import com.volmit.iris.gen.atomics.AtomicCache; -import com.volmit.iris.util.BiomeRarityCellGenerator; +import com.volmit.iris.util.RarityCellGenerator; import com.volmit.iris.util.CNG; import com.volmit.iris.util.Desc; import com.volmit.iris.util.DontObfuscate; @@ -90,12 +90,16 @@ public class IrisBiome extends IrisRegistrant @Desc("Generators for this biome. Multiple generators with different interpolation sizes will mix with other biomes how you would expect. This defines your biome height relative to the fluid height. Use negative for oceans.") private KList generators = new KList().qadd(new IrisBiomeGeneratorLink()); + @DontObfuscate + @Desc("A list of structure tilesets") + private KList structures = new KList<>(); + @DontObfuscate @Desc("Define biome deposit generators that add onto the existing regional and global deposit generators") private KList deposits = new KList<>(); private transient InferredType inferredType; - private transient AtomicCache childrenCell = new AtomicCache<>(); + private transient AtomicCache childrenCell = new AtomicCache<>(); private transient AtomicCache biomeGenerator = new AtomicCache<>(); private transient AtomicCache maxHeight = new AtomicCache<>(); private transient AtomicCache> realChildren = new AtomicCache<>(); @@ -127,11 +131,11 @@ public class IrisBiome extends IrisRegistrant }); } - public BiomeRarityCellGenerator getChildrenGenerator(RNG random, int sig, double scale) + public RarityCellGenerator getChildrenGenerator(RNG random, int sig, double scale) { return childrenCell.aquire(() -> { - BiomeRarityCellGenerator childrenCell = new BiomeRarityCellGenerator(random.nextParallelRNG(sig * 2137)); + RarityCellGenerator childrenCell = new RarityCellGenerator(random.nextParallelRNG(sig * 2137)); childrenCell.setCellScale(scale); return childrenCell; }); diff --git a/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java b/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java new file mode 100644 index 000000000..c52c5cc0e --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisCompatabilityFilter.java @@ -0,0 +1,54 @@ +package com.volmit.iris.object; + +import org.bukkit.block.data.BlockData; + +import com.volmit.iris.gen.atomics.AtomicCache; +import com.volmit.iris.util.BlockDataTools; +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; + +import lombok.Data; + +@Desc("Find and replace object materials for compatability") +@Data +public class IrisCompatabilityFilter +{ + @DontObfuscate + private String when; + + @DontObfuscate + private String supplement; + + @DontObfuscate + private boolean exact = false; + + private transient AtomicCache findData = new AtomicCache<>(); + private transient AtomicCache replaceData = new AtomicCache<>(); + + public IrisCompatabilityFilter(String when, String supplement) + { + this(when, supplement, false); + } + + public IrisCompatabilityFilter(String when, String supplement, boolean exact) + { + this.when = when; + this.supplement = supplement; + this.exact = exact; + } + + public IrisCompatabilityFilter() + { + + } + + public BlockData getFind() + { + return findData.aquire(() -> BlockDataTools.getBlockData(when)); + } + + public BlockData getReplace() + { + return replaceData.aquire(() -> BlockDataTools.getBlockData(supplement)); + } +} diff --git a/src/main/java/com/volmit/iris/object/IrisDimension.java b/src/main/java/com/volmit/iris/object/IrisDimension.java index 8d6505d0c..23a4f58da 100644 --- a/src/main/java/com/volmit/iris/object/IrisDimension.java +++ b/src/main/java/com/volmit/iris/object/IrisDimension.java @@ -101,6 +101,10 @@ public class IrisDimension extends IrisRegistrant @Desc("Post Processors") private KList postProcessors = getDefaultPostProcessors(); + @DontObfuscate + @Desc("Compatability filters") + private KList compatability = getDefaultCompatability(); + @DontObfuscate @Desc("The ceiling dimension. Leave blank for normal sky.") private String ceiling = ""; @@ -246,6 +250,112 @@ public class IrisDimension extends IrisRegistrant }); } + private KList getDefaultCompatability() + { + KList filters = new KList<>(); + + // Below 1.16 + // 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", "LEGACY_NETHER_FENCE")); + filters.add(new IrisCompatabilityFilter("NETHERITE_BLOCK", "QUARTZ_BLOCK")); + filters.add(new IrisCompatabilityFilter("BLACKSTONE", "COBBLESTONE")); + filters.add(new IrisCompatabilityFilter("BASALT", "STONE")); + filters.add(new IrisCompatabilityFilter("ANCIENT_DEBRIS", "NETHERRACK")); + filters.add(new IrisCompatabilityFilter("NETHERRACK", "LEGACY_NETHERRACK")); + + // Below 1.15 + filters.add(new IrisCompatabilityFilter("HONEY_BLOCK", "OAK_LEAVES")); + filters.add(new IrisCompatabilityFilter("BEEHIVE", "OAK_LEAVES")); + filters.add(new IrisCompatabilityFilter("BEE_NEST", "OAK_LEAVES")); + + // Below 1.14 + filters.add(new IrisCompatabilityFilter("GRANITE_WALL", "COBBLESTONE_WALL")); + filters.add(new IrisCompatabilityFilter("DIORITE_WALL", "COBBLESTONE_WALL")); + filters.add(new IrisCompatabilityFilter("ANDESITE_WALL", "COBBLESTONE_WALL")); + filters.add(new IrisCompatabilityFilter("SWEET_BERRY_BUSH", "GRASS")); + filters.add(new IrisCompatabilityFilter("STONECUTTER", "CRAFTING_TABLE")); + filters.add(new IrisCompatabilityFilter("SANDSTONE_STAIRS", "LEGACY_SANDSTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("SMOOTH_SANDSTONE_STAIRS", "LEGACY_SANDSTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("MOSSY_COBBLESTONE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("MOSSY_STONE_BRICK_STAIRS", "STONE_BRICK_STAIRS")); + filters.add(new IrisCompatabilityFilter("POLISHED_GRANITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("GRANITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("POLISHED_DIORITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("DIORITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("POLISHED_ANDESITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("ANDESITE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("STONE_STAIRS", "COBBLESTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("END_STONE_BRICK_STAIRS", "LEGACY_SANDSTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("NETHER_BRICK_STAIRS", "LEGACY_NETHER_BRICK_STAIRS")); + filters.add(new IrisCompatabilityFilter("RED_NETHER_BRICK_STAIRS", "NETHER_BRICK_STAIRS")); + filters.add(new IrisCompatabilityFilter("SMOOTH_QUARTZ_STAIRS", "LEGACY_QUARTZ_STAIRS")); + filters.add(new IrisCompatabilityFilter("QUARTZ_STAIRS", "LEGACY_QUARTZ_STAIRS")); + filters.add(new IrisCompatabilityFilter("RED_SANDSTONE_STAIRS", "LEGACY_RED_SANDSTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("SMOOTH_RED_SANDSTONE_STAIRS", "LEGACY_RED_SANDSTONE_STAIRS")); + filters.add(new IrisCompatabilityFilter("STONE_SLAB", "SMOOTH_STONE_SLAB")); + filters.add(new IrisCompatabilityFilter("SMOKER", "FURNACE")); + filters.add(new IrisCompatabilityFilter("SMITHING_TABLE", "CRAFTING_TABLE")); + filters.add(new IrisCompatabilityFilter("END_STONE_BRICK_SLAB", "SANDSTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("RED_NETHER_BRICK_SLAB", "NETHER_BRICK_SLAB")); + filters.add(new IrisCompatabilityFilter("SMOOTH_QUARTZ_SLAB", "QUARTZ_SLAB")); + filters.add(new IrisCompatabilityFilter("CUT_SANDSTONE_SLAB", "SANDSTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("CUT_RED_SANDSTONE_SLAB", "RED_SANDSTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("SMOOTH_RED_SANDSTONE_SLAB", "RED_SANDSTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("SMOOTH_SANDSTONE_SLAB", "SANDSTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("MOSSY_COBBLESTONE_SLAB", "COBBLESTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("MOSSY_STONE_BRICK_SLAB", "STONE_BRICK_SLAB")); + filters.add(new IrisCompatabilityFilter("STONE_SLAB", "SMOOTH_STONE_SLAB")); + filters.add(new IrisCompatabilityFilter("ANDESITE_SLAB", "COBBLESTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("ANDESITE_SLAB", "COBBLESTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("DIORITE_SLAB", "COBBLESTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("GRANITE_SLAB", "COBBLESTONE_SLAB")); + filters.add(new IrisCompatabilityFilter("POLISHED_ANDESITE_SLAB", "SMOOTH_STONE_SLAB")); + filters.add(new IrisCompatabilityFilter("POLISHED_DIORITE_SLAB", "SMOOTH_STONE_SLAB")); + filters.add(new IrisCompatabilityFilter("POLISHED_GRANITE_SLAB", "SMOOTH_STONE_SLAB")); + filters.add(new IrisCompatabilityFilter("WARPED_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("WARPED_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("SPRUCE_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("SPRUCE_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("OAK_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("OAK_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("JUNGLE_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("JUNGLE_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("DARK_OAK_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("DARK_OAK_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("CRIMSON_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("CRIMSON_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("BIRCH_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("BIRCH_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("ACACIA_WALL_SIGN", "LEGACY_WALL_SIGN")); + filters.add(new IrisCompatabilityFilter("ACACIA_SIGN", "LEGACY_SIGN_POST")); + filters.add(new IrisCompatabilityFilter("SCAFFOLDING", "BIRCH_FENCE")); + filters.add(new IrisCompatabilityFilter("LOOM", "LOOM")); + filters.add(new IrisCompatabilityFilter("LECTERN", "BOOKSHELF")); + filters.add(new IrisCompatabilityFilter("LANTERN", "REDSTONE_LAMP")); + filters.add(new IrisCompatabilityFilter("JIGSAW", "AIR")); + filters.add(new IrisCompatabilityFilter("GRINDSTONE", "COBBLESTONE")); + filters.add(new IrisCompatabilityFilter("FLETCHING_TABLE", "CRAFTING_TABLE")); + filters.add(new IrisCompatabilityFilter("COMPOSTER", "CHEST")); + filters.add(new IrisCompatabilityFilter("CARTOGRAPHY_TABLE", "CRAFTING_TABLE")); + filters.add(new IrisCompatabilityFilter("CAMPFIRE", "DARK_OAK_SLAB")); + filters.add(new IrisCompatabilityFilter("BLAST_FURNACE", "FURNACE")); + filters.add(new IrisCompatabilityFilter("BELL", "REDSTONE_LAMP")); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=south]", "minecraft:hay_bale[axis=z]", true)); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=north]", "minecraft:hay_bale[axis=z]", true)); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=east]", "minecraft:hay_bale[axis=x]", true)); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=west]", "minecraft:hay_bale[axis=x]", true)); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=up]", "minecraft:hay_bale[axis=y]", true)); + filters.add(new IrisCompatabilityFilter("minecraft:barrel[facing=down]", "minecraft:hay_bale[axis=y]", true)); + 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; + } + public CNG getCoordFracture(RNG rng, int signature) { return coordFracture.aquire(() -> diff --git a/src/main/java/com/volmit/iris/object/IrisObject.java b/src/main/java/com/volmit/iris/object/IrisObject.java index d7c157eb8..a74c69df2 100644 --- a/src/main/java/com/volmit/iris/object/IrisObject.java +++ b/src/main/java/com/volmit/iris/object/IrisObject.java @@ -29,6 +29,7 @@ import lombok.EqualsAndHashCode; public class IrisObject extends IrisRegistrant { private static final Material SNOW = Material.SNOW; + 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; @@ -131,6 +132,12 @@ public class IrisObject extends IrisRegistrant int spiny = rng.imax() / 1000; int spinz = rng.imax() / 1000; int y = yv < 0 ? placer.getHighest(x, z, config.isUnderwater()) + config.getRotation().rotate(new BlockVector(0, getCenter().getBlockY(), 0), spinx, spiny, spinz).getBlockY() : yv; + + if(yv >= 0 && config.isBottom()) + { + y += Math.floorDiv(h, 2); + } + KMap heightmap = config.getSnow() > 0 ? new KMap<>() : null; if(yv < 0) @@ -141,6 +148,20 @@ public class IrisObject extends IrisRegistrant } } + if(config.isBore()) + { + for(int i = x - Math.floorDiv(w, 2); i <= x + Math.floorDiv(w, 2); i++) + { + for(int j = y - 1; j <= y + h - 2; j++) + { + for(int k = z - Math.floorDiv(d, 2); k <= z + Math.floorDiv(d, 2); k++) + { + placer.set(i, j, k, AIR); + } + } + } + } + for(BlockVector g : blocks.keySet()) { BlockVector i = g.clone(); diff --git a/src/main/java/com/volmit/iris/object/IrisObjectPlacement.java b/src/main/java/com/volmit/iris/object/IrisObjectPlacement.java index 3e7a35ede..c99e37733 100644 --- a/src/main/java/com/volmit/iris/object/IrisObjectPlacement.java +++ b/src/main/java/com/volmit/iris/object/IrisObjectPlacement.java @@ -51,6 +51,14 @@ public class IrisObjectPlacement @Desc("If set to true, this object will only place parts of itself where blocks already exist.") private boolean meld = false; + @DontObfuscate + @Desc("If set to true, this object will place from the ground up instead of height checks when not y locked to the surface.") + private boolean bottom = false; + + @DontObfuscate + @Desc("If set to true, air will be placed before the schematic places.") + private boolean bore = false; + public IrisObjectPlacement() { diff --git a/src/main/java/com/volmit/iris/object/IrisRegion.java b/src/main/java/com/volmit/iris/object/IrisRegion.java index 02ddd6458..3f304fa22 100644 --- a/src/main/java/com/volmit/iris/object/IrisRegion.java +++ b/src/main/java/com/volmit/iris/object/IrisRegion.java @@ -70,6 +70,10 @@ public class IrisRegion extends IrisRegistrant @Desc("The biome implosion ratio, how much to implode biomes into children (chance)") private double biomeImplosionRatio = 0.4; + @DontObfuscate + @Desc("A list of structure tilesets") + private KList structures = new KList<>(); + @DontObfuscate @Desc("A list of root-level biomes in this region. Don't specify child biomes of other biomes here. Just the root parents.") private KList landBiomes = new KList<>(); diff --git a/src/main/java/com/volmit/iris/object/IrisRegistrant.java b/src/main/java/com/volmit/iris/object/IrisRegistrant.java index 1da3c211d..fa34f21df 100644 --- a/src/main/java/com/volmit/iris/object/IrisRegistrant.java +++ b/src/main/java/com/volmit/iris/object/IrisRegistrant.java @@ -7,7 +7,7 @@ import lombok.Data; @Data public class IrisRegistrant { - private String loadKey; + private transient String loadKey; - private File loadFile; + private transient File loadFile; } diff --git a/src/main/java/com/volmit/iris/object/IrisStructure.java b/src/main/java/com/volmit/iris/object/IrisStructure.java new file mode 100644 index 000000000..2d90f5a70 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisStructure.java @@ -0,0 +1,163 @@ +package com.volmit.iris.object; + +import com.volmit.iris.gen.atomics.AtomicCache; +import com.volmit.iris.util.CNG; +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; +import com.volmit.iris.util.KList; +import com.volmit.iris.util.RNG; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@DontObfuscate +@Desc("Represents a structure in iris.") +@Data +@EqualsAndHashCode(callSuper = false) +public class IrisStructure extends IrisRegistrant +{ + @DontObfuscate + @Desc("This is the human readable name for this structure. Such as Red Dungeon or Tropical Village.") + private String name = "A Structure Type"; + + @DontObfuscate + @Desc("This is the x and z size of each grid cell") + private int gridSize = 11; + + @DontObfuscate + @Desc("This is the y size of each grid cell") + private int gridHeight = 5; + + @DontObfuscate + @Desc("This is the maximum layers iris will generate for (height cells)") + private int maxLayers = 1; + + @DontObfuscate + @Desc("This is the wall chance. Higher values makes more rooms and less open halls") + private double wallChance = 0.25; + + @DontObfuscate + @Desc("Edges of tiles replace each other instead of having their own.") + private boolean mergeEdges = true; + + @DontObfuscate + @Desc("The tiles") + private KList tiles = new KList<>(); + + @DontObfuscate + @Desc("This is the wall chance zoom") + private double wallChanceZoom = 1D; + + @DontObfuscate + @Desc("The dispersion of walls") + private Dispersion dispersion = Dispersion.SCATTER; + + private transient AtomicCache wallGenerator = new AtomicCache<>(); + + public TileResult getTile(RNG rng, double x, double y, double z) + { + KList walls = new KList<>(); + boolean floor = isWall(rng, x, y, z, StructureTileFace.DOWN); + boolean ceiling = isWall(rng, x, y, z, StructureTileFace.UP); + + if(isWall(rng, x, y, z, StructureTileFace.NORTH)) + { + walls.add(StructureTileFace.NORTH); + } + + if(isWall(rng, x, y, z, StructureTileFace.SOUTH)) + { + walls.add(StructureTileFace.SOUTH); + } + + if(isWall(rng, x, y, z, StructureTileFace.EAST)) + { + walls.add(StructureTileFace.EAST); + } + + if(isWall(rng, x, y, z, StructureTileFace.WEST)) + { + walls.add(StructureTileFace.WEST); + } + + int rt = 0; + + for(int cx = 0; cx < 4; cx++) + { + for(IrisStructureTile i : tiles) + { + if(i.likeAGlove(floor, ceiling, walls)) + { + return new TileResult(i, rt); + } + } + + if(cx < 3) + { + rotate(walls); + rt += 90; + } + } + + return null; + } + + public void rotate(KList faces) + { + for(int i = 0; i < faces.size(); i++) + { + faces.set(i, faces.get(i).rotate90CW()); + } + } + + public boolean isWall(RNG rng, double x, double y, double z, StructureTileFace face) + { + if(face == StructureTileFace.DOWN && maxLayers == 1) + { + return true; + } + + return isWall(rng, x, y, z, (face.ordinal() + 12) * 3); + } + + private boolean isWall(RNG rng, double x, double y, double z, int side) + { + return getWallGenerator(rng).fitDoubleD(0, 1, (getTileHorizon(x) + side) / wallChanceZoom, (getTileVertical(y) + side) / wallChanceZoom, (getTileHorizon(z) - side) / wallChanceZoom) < getWallChance(); + } + + public int getTileHorizon(double v) + { + return (int) Math.floor(v / gridSize); + } + + public int getTileVertical(double v) + { + return (int) Math.floor(v / gridHeight); + } + + public CNG getWallGenerator(RNG rng) + { + return wallGenerator.aquire(() -> + { + CNG wallGenerator = new CNG(rng); + RNG rngx = rng.nextParallelRNG((int) ((wallChance * 102005) + gridHeight - gridSize + maxLayers + tiles.size())); + + switch(dispersion) + { + case SCATTER: + wallGenerator = CNG.signature(rngx).freq(1000000); + break; + case WISPY: + wallGenerator = CNG.signature(rngx); + break; + } + + return wallGenerator; + }); + } + + public IrisStructure() + { + + } +} diff --git a/src/main/java/com/volmit/iris/object/IrisStructurePlacement.java b/src/main/java/com/volmit/iris/object/IrisStructurePlacement.java new file mode 100644 index 000000000..b3a5678c1 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisStructurePlacement.java @@ -0,0 +1,134 @@ +package com.volmit.iris.object; + +import com.volmit.iris.Iris; +import com.volmit.iris.gen.ParallaxChunkGenerator; +import com.volmit.iris.gen.atomics.AtomicCache; +import com.volmit.iris.util.CellGenerator; +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; +import com.volmit.iris.util.RNG; + +import lombok.Data; + +@Data +public class IrisStructurePlacement +{ + @DontObfuscate + @Desc("The structure tileset to use") + private String tileset = ""; + + @DontObfuscate + @Desc("The structure chance zoom. Higher = bigger cells, further away") + private double zoom = 1D; + + @DontObfuscate + @Desc("The ratio. Lower values means cells can get closer to other cells. Negative values means make veins of structures") + private double ratio = 0.25D; + + @DontObfuscate + @Desc("The rarity for this structure") + private int rarity = 4; + + @DontObfuscate + @Desc("The height or -1 for surface") + private int height = -1; + + @DontObfuscate + @Desc("The chance cell shuffle (rougher edges)") + private double shuffle = 22; + + private transient AtomicCache chanceCell = new AtomicCache<>(); + private transient AtomicCache structure = new AtomicCache<>(); + private transient AtomicCache config = new AtomicCache<>(); + + public IrisStructurePlacement() + { + + } + + public void place(ParallaxChunkGenerator g, RNG rng, int cx, int cz) + { + try + { + TileResult t; + IrisObject o; + int h; + RNG rnp = rng.nextParallelRNG(cx - (cz * cz)); + int s = gridSize() - (getStructure().isMergeEdges() ? 1 : 0); + + for(int i = cx << 4; i < (cx << 4) + 15; i += Math.max(s / 2, 1)) + { + for(int j = cz << 4; j < (cz << 4) + 15; j += Math.max(s / 2, 1)) + { + for(int k = 0; k < s * getStructure().getMaxLayers(); k += Math.max(s, 1)) + { + if(!hasStructure(rng, i, k, j)) + { + continue; + } + + h = (height == -1 ? 0 : height) + (Math.floorDiv(k, s) * s); + t = getStructure().getTile(rng, i / zoom, h / zoom, j / zoom); + + if(t != null) + { + if(height >= 0) + { + t.getPlacement().setBore(true); + } + + o = load(t.getTile().getObjects().get(rnp.nextInt(t.getTile().getObjects().size()))); + o.place(Math.floorDiv(i, s) * s, height == -1 ? -1 : h, Math.floorDiv(j, s) * s, g, t.getPlacement(), rng); + } + } + } + } + } + + catch(Throwable e) + { + e.printStackTrace(); + } + } + + private IrisObjectPlacement getConfig() + { + return config.aquire(() -> new IrisObjectPlacement()); + } + + public IrisObject load(String s) + { + return Iris.data.getObjectLoader().load(s); + } + + public int gridSize() + { + return getStructure().getGridSize(); + } + + public IrisStructure getStructure() + { + return structure.aquire(() -> Iris.data.getStructureLoader().load(getTileset())); + } + + public boolean hasStructure(RNG random, double x, double y, double z) + { + if(getChanceGenerator(random).getIndex(x, y, z, getRarity()) == getRarity() / 2) + { + return ratio > 0 ? getChanceGenerator(random).getDistance(x, z) > ratio : getChanceGenerator(random).getDistance(x, z) < Math.abs(ratio); + } + + return false; + } + + public CellGenerator getChanceGenerator(RNG random) + { + return chanceCell.aquire(() -> + { + CellGenerator chanceCell = new CellGenerator(random.nextParallelRNG(-72346)); + chanceCell.setCellScale(1D); + chanceCell.setShuffle(getShuffle()); + return chanceCell; + }); + } +} diff --git a/src/main/java/com/volmit/iris/object/IrisStructureTile.java b/src/main/java/com/volmit/iris/object/IrisStructureTile.java new file mode 100644 index 000000000..d483d3439 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/IrisStructureTile.java @@ -0,0 +1,95 @@ +package com.volmit.iris.object; + +import com.volmit.iris.util.Desc; +import com.volmit.iris.util.DontObfuscate; +import com.volmit.iris.util.KList; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@DontObfuscate +@Desc("Represents a structure tile") +@Data +@EqualsAndHashCode(callSuper = false) +public class IrisStructureTile +{ + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a ceiling?") + private StructureTileCondition ceiling = StructureTileCondition.AGNOSTIC; + + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a floor?") + private StructureTileCondition floor = StructureTileCondition.REQUIRED; + + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a north wall?") + private StructureTileCondition north = StructureTileCondition.AGNOSTIC; + + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a south wall?") + private StructureTileCondition south = StructureTileCondition.AGNOSTIC; + + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a east wall?") + private StructureTileCondition east = StructureTileCondition.AGNOSTIC; + + @DontObfuscate + @Desc("Is this structure allowed to place if there is supposed to be a west wall?") + private StructureTileCondition west = StructureTileCondition.AGNOSTIC; + + @DontObfuscate + @Desc("List of objects to place centered in this tile") + private KList objects = new KList<>(); + + public IrisStructureTile() + { + + } + + public boolean likeAGlove(boolean floor, boolean ceiling, KList walls) + { + //@builder + + if((getFloor().required() && !floor) || (getCeiling().required() && !ceiling)) + { + return false; + } + + if((!getFloor().supported() && floor) || (!getCeiling().supported() && ceiling)) + { + return false; + } + + if(!fitsWalls(walls)) + { + return false; + } + + //@done + + return true; + } + + private boolean fitsWalls(KList walls) + { + //@builder + if((getNorth().required() && !walls.contains(StructureTileFace.NORTH)) + || (getSouth().required() && !walls.contains(StructureTileFace.SOUTH)) + || (getEast().required() && !walls.contains(StructureTileFace.EAST)) + || (getWest().required() && !walls.contains(StructureTileFace.WEST))) + { + return false; + } + + if((!getNorth().supported() && walls.contains(StructureTileFace.NORTH)) + || (!getSouth().supported() && walls.contains(StructureTileFace.SOUTH)) + || (!getEast().supported() && walls.contains(StructureTileFace.EAST)) + || (!getWest().supported() && walls.contains(StructureTileFace.WEST))) + { + return false; + } + //@done + + return true; + } +} diff --git a/src/main/java/com/volmit/iris/object/StructureTileCondition.java b/src/main/java/com/volmit/iris/object/StructureTileCondition.java new file mode 100644 index 000000000..ea1a50f49 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/StructureTileCondition.java @@ -0,0 +1,25 @@ +package com.volmit.iris.object; + +import com.volmit.iris.util.DontObfuscate; + +public enum StructureTileCondition +{ + @DontObfuscate + REQUIRED, + + @DontObfuscate + AGNOSTIC, + + @DontObfuscate + NEVER; + + public boolean supported() + { + return !this.equals(NEVER); + } + + public boolean required() + { + return this.equals(REQUIRED); + } +} diff --git a/src/main/java/com/volmit/iris/object/StructureTileFace.java b/src/main/java/com/volmit/iris/object/StructureTileFace.java new file mode 100644 index 000000000..78e58dadb --- /dev/null +++ b/src/main/java/com/volmit/iris/object/StructureTileFace.java @@ -0,0 +1,28 @@ +package com.volmit.iris.object; + +public enum StructureTileFace +{ + UP, + DOWN, + NORTH, + SOUTH, + EAST, + WEST; + + public StructureTileFace rotate90CW() + { + switch(this) + { + case EAST: + return SOUTH; + case NORTH: + return EAST; + case SOUTH: + return WEST; + case WEST: + return NORTH; + default: + return this; + } + } +} diff --git a/src/main/java/com/volmit/iris/object/TileResult.java b/src/main/java/com/volmit/iris/object/TileResult.java new file mode 100644 index 000000000..c00b0c121 --- /dev/null +++ b/src/main/java/com/volmit/iris/object/TileResult.java @@ -0,0 +1,21 @@ +package com.volmit.iris.object; + +import lombok.Data; + +@Data +public class TileResult +{ + private IrisStructureTile tile; + private IrisObjectPlacement placement; + + public TileResult(IrisStructureTile tile, int rot) + { + this.tile = tile; + IrisObjectPlacement p = new IrisObjectPlacement(); + IrisObjectRotation rt = new IrisObjectRotation(); + rt.setYAxis(new IrisAxisRotationClamp(rot != 0, rot, rot, 0)); + p.setRotation(rt); + p.setBottom(true); + placement = p; + } +} diff --git a/src/main/java/com/volmit/iris/util/CellGenerator.java b/src/main/java/com/volmit/iris/util/CellGenerator.java index ec273d53f..3ecad03e8 100644 --- a/src/main/java/com/volmit/iris/util/CellGenerator.java +++ b/src/main/java/com/volmit/iris/util/CellGenerator.java @@ -54,10 +54,24 @@ public class CellGenerator { return 0; } - + return ((fn.GetCellular((float) ((x * cellScale) + (cng.noise(x, z) * shuffle)), (float) ((z * cellScale) + (cng.noise(z, x) * shuffle))) + 1f) / 2f) * (possibilities - 1); } + public float getValue(double x, double y, double z, int possibilities) + { + if(possibilities == 1) + { + return 0; + } + + return ((fn.GetCellular((float) ((x * cellScale) + (cng.noise(x, z) * shuffle)), + + (float) ((y * cellScale) + (cng.noise(x, y) * shuffle)) + + , (float) ((z * cellScale) + (cng.noise(z, x) * shuffle))) + 1f) / 2f) * (possibilities - 1); + } + public int getIndex(double x, double z, int possibilities) { if(possibilities == 1) @@ -67,4 +81,14 @@ public class CellGenerator return (int) Math.round(getValue(x, z, possibilities)); } + + public int getIndex(double x, double y, double z, int possibilities) + { + if(possibilities == 1) + { + return 0; + } + + return (int) Math.round(getValue(x, y, z, possibilities)); + } } diff --git a/src/main/java/com/volmit/iris/util/PregenJob.java b/src/main/java/com/volmit/iris/util/PregenJob.java new file mode 100644 index 000000000..1a6527634 --- /dev/null +++ b/src/main/java/com/volmit/iris/util/PregenJob.java @@ -0,0 +1,186 @@ +package com.volmit.iris.util; + +import org.bukkit.Bukkit; +import org.bukkit.Chunk; +import org.bukkit.World; + +import com.volmit.iris.Iris; + +public class PregenJob +{ + private World world; + private int size; + private int mcaX; + private int mcaZ; + private int rcx; + private int rcz; + private int total; + private int genned; + private boolean completed; + public static int task = -1; + private PrecisionStopwatch s; + private ChronoLatch cl; + + public PregenJob(World world, int size) + { + this.s = PrecisionStopwatch.start(); + this.world = world; + this.size = size; + world.getWorldBorder().setCenter(0, 0); + world.getWorldBorder().setWarningDistance(64); + world.getWorldBorder().setSize(size); + mcaX = mca(min()); + mcaZ = mca(min()); + rcx = 0; + cl = new ChronoLatch(3000); + rcz = 0; + total = (size / 16) * (size / 16); + genned = 0; + completed = false; + + if(task != -1) + { + stop(); + } + + task = Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, this::onTick, 0, 0); + } + + public static void stop() + { + try + { + Bukkit.getScheduler().cancelTask(task); + } + + catch(Throwable e) + { + + } + task = -1; + } + + public void onTick() + { + if(completed) + { + return; + } + + PrecisionStopwatch p = PrecisionStopwatch.start(); + + while(p.getMilliseconds() < 1500) + { + tick(); + } + + if(cl.flip()) + { + tickMetrics(); + } + } + + private void tickMetrics() + { + long eta = (long) ((total - genned) * (s.getMilliseconds() / (double) genned)); + Iris.info("Pregen: Generating: " + Form.pc(Math.min((double) genned / (double) total, 1.0), 0) + ", Elapsed: " + Form.duration((long) s.getMilliseconds()) + ", ETA: " + (genned >= total - 5 ? "Any second..." : s.getMilliseconds() < 25000 ? "Calculating..." : Form.duration(eta)) + " MS: " + Form.duration((s.getMilliseconds() / (double) genned), 2)); + } + + public void tick() + { + gen(); + nextPosition(); + } + + public void nextPosition() + { + rcx++; + + if(rcx > 31) + { + rcx = 0; + rcz++; + + if(rcz > 31) + { + rcz = 0; + mcaX++; + + if(mcaX > mca(max() / 16)) + { + mcaX = mca(min() / 16); + mcaZ++; + + if(mcaZ > mca(max() / 16)) + { + mcaZ = mca(min() / 16); + completed = true; + stop(); + Iris.info("Pregen Completed!"); + + for(Chunk i : world.getLoadedChunks()) + { + i.unload(true); + } + + world.save(); + return; + } + + world.save(); + } + } + } + } + + public void gen() + { + try + { + if(isChunkWithin(rcx + minMCA(mcaX), rcz + minMCA(mcaZ))) + { + Chunk c = world.getChunkAt(rcx + minMCA(mcaX), rcz + minMCA(mcaZ)); + c.load(true); + world.unloadChunkRequest(rcx + minMCA(mcaX), rcz + minMCA(mcaZ)); + genned++; + } + } + + catch(Throwable e) + { + Iris.warn("Pregen Crash!"); + e.printStackTrace(); + stop(); + } + } + + public int minMCA(int v) + { + return v << 5; + } + + public int maxMCA(int v) + { + return (v << 5) + 31; + } + + public int mca(int v) + { + return v >> 5; + } + + public int max() + { + return size / 2; + } + + public int min() + { + return -max(); + } + + public boolean isChunkWithin(int x, int z) + { + return Math.abs(z * 16) <= size / 2 && Math.abs(z * 16) <= size / 2; + } +} diff --git a/src/main/java/com/volmit/iris/util/BiomeRarityCellGenerator.java b/src/main/java/com/volmit/iris/util/RarityCellGenerator.java similarity index 89% rename from src/main/java/com/volmit/iris/util/BiomeRarityCellGenerator.java rename to src/main/java/com/volmit/iris/util/RarityCellGenerator.java index 6a556553a..7fad49f60 100644 --- a/src/main/java/com/volmit/iris/util/BiomeRarityCellGenerator.java +++ b/src/main/java/com/volmit/iris/util/RarityCellGenerator.java @@ -2,9 +2,9 @@ package com.volmit.iris.util; import com.volmit.iris.object.IrisBiome; -public class BiomeRarityCellGenerator extends CellGenerator +public class RarityCellGenerator extends CellGenerator { - public BiomeRarityCellGenerator(RNG rng) + public RarityCellGenerator(RNG rng) { super(rng); }