From 8a959ad72a4b2dfde793fa2df351032531837858 Mon Sep 17 00:00:00 2001 From: Unknown Date: Wed, 27 Nov 2019 07:17:38 -0500 Subject: [PATCH] added ore finders --- .../kaptainwutax/seedcracker/FinderQueue.java | 19 +- .../seedcracker/finder/DiamondOreFinder.java | 57 +++++ .../finder/InfestedStoneOreFinder.java | 59 +++++ .../seedcracker/finder/OreFinder.java | 205 ++++++++++++++++++ 4 files changed, 338 insertions(+), 2 deletions(-) create mode 100644 src/main/java/kaptainwutax/seedcracker/finder/DiamondOreFinder.java create mode 100644 src/main/java/kaptainwutax/seedcracker/finder/InfestedStoneOreFinder.java create mode 100644 src/main/java/kaptainwutax/seedcracker/finder/OreFinder.java diff --git a/src/main/java/kaptainwutax/seedcracker/FinderQueue.java b/src/main/java/kaptainwutax/seedcracker/FinderQueue.java index a169897..4f8c95f 100644 --- a/src/main/java/kaptainwutax/seedcracker/FinderQueue.java +++ b/src/main/java/kaptainwutax/seedcracker/FinderQueue.java @@ -18,6 +18,7 @@ public class FinderQueue { private final static FinderQueue INSTANCE = new FinderQueue(); public static final ExecutorService SERVICE = Executors.newFixedThreadPool(5); + public RenderType renderType = RenderType.XRAY; private List finderBuilders = new ArrayList<>(); private Set activeFinders = new ConcurrentSet<>(); @@ -47,10 +48,14 @@ public class FinderQueue { } public void renderFinders() { + if(this.renderType == RenderType.OFF)return; + GlStateManager.disableTexture(); //Makes it render through blocks. - GlStateManager.disableDepthTest(); + if(this.renderType == RenderType.XRAY) { + GlStateManager.disableDepthTest(); + } this.activeFinders.forEach(finder -> { if(finder.shouldRender()) { @@ -59,7 +64,10 @@ public class FinderQueue { }); GlStateManager.enableTexture(); - GlStateManager.enableDepthTest(); + + if(this.renderType == RenderType.XRAY) { + GlStateManager.enableDepthTest(); + } } public void clear() { @@ -76,6 +84,13 @@ public class FinderQueue { this.finderBuilders.add(OceanMonumentFinder::create); this.finderBuilders.add(EndCityFinder::create); this.finderBuilders.add(IglooFinder::create); + + //this.finderBuilders.add(DiamondOreFinder::create); + //this.finderBuilders.add(InfestedStoneOreFinder::create); + } + + public enum RenderType { + OFF, ON, XRAY } } diff --git a/src/main/java/kaptainwutax/seedcracker/finder/DiamondOreFinder.java b/src/main/java/kaptainwutax/seedcracker/finder/DiamondOreFinder.java new file mode 100644 index 0000000..89b15fe --- /dev/null +++ b/src/main/java/kaptainwutax/seedcracker/finder/DiamondOreFinder.java @@ -0,0 +1,57 @@ +package kaptainwutax.seedcracker.finder; + +import kaptainwutax.seedcracker.render.Cube; +import net.minecraft.block.Blocks; +import net.minecraft.client.util.math.Vector4f; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.World; +import net.minecraft.world.gen.feature.OreFeatureConfig; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +public class DiamondOreFinder extends OreFinder { + + public static OreFeatureConfig CONFIG = new OreFeatureConfig(OreFeatureConfig.Target.NATURAL_STONE, Blocks.DIAMOND_ORE.getDefaultState(), 8); + + protected static List SEARCH_POSITIONS = buildSearchPositions(CHUNK_POSITIONS, pos -> { + if(pos.getY() > 16)return true; + return false; + }); + + public DiamondOreFinder(World world, ChunkPos chunkPos) { + super(world, chunkPos, CONFIG); + this.searchPositions = SEARCH_POSITIONS; + } + + @Override + public void findOreVeins(List> veins) { + List starts = new ArrayList<>(); + + for(Set vein: veins) { + BlockPos oreStart = new BlockPos( + this.findX(vein, OreFinder.HIGHEST), + this.findY(vein, OreFinder.LOWEST) + 3, + this.findZ(vein, OreFinder.HIGHEST) + ); + + starts.add(oreStart); + } + + starts.forEach(start -> { + this.renderers.add(new Cube(start, new Vector4f(1.0f, 1.0f, 1.0f, 1.0f))); + }); + } + + public static List create(World world, ChunkPos chunkPos) { + List finders = new ArrayList<>(); + finders.add(new DiamondOreFinder(world, chunkPos)); + finders.add(new DiamondOreFinder(world, new ChunkPos(chunkPos.x + 1, chunkPos.z))); + finders.add(new DiamondOreFinder(world, new ChunkPos(chunkPos.x, chunkPos.z + 1))); + finders.add(new DiamondOreFinder(world, new ChunkPos(chunkPos.x + 1, chunkPos.z + 1))); + return finders; + } + +} diff --git a/src/main/java/kaptainwutax/seedcracker/finder/InfestedStoneOreFinder.java b/src/main/java/kaptainwutax/seedcracker/finder/InfestedStoneOreFinder.java new file mode 100644 index 0000000..9ec8791 --- /dev/null +++ b/src/main/java/kaptainwutax/seedcracker/finder/InfestedStoneOreFinder.java @@ -0,0 +1,59 @@ +package kaptainwutax.seedcracker.finder; + +import kaptainwutax.seedcracker.render.Cube; +import net.minecraft.block.Blocks; +import net.minecraft.client.util.math.Vector4f; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.World; +import net.minecraft.world.gen.feature.OreFeatureConfig; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +public class InfestedStoneOreFinder extends OreFinder { + + public static OreFeatureConfig CONFIG = new OreFeatureConfig(OreFeatureConfig.Target.NATURAL_STONE, Blocks.INFESTED_STONE.getDefaultState(), 9); + + protected static List SEARCH_POSITIONS = buildSearchPositions(CHUNK_POSITIONS, pos -> { + if(pos.getY() > 70)return true; + return false; + }); + + public InfestedStoneOreFinder(World world, ChunkPos chunkPos) { + super(world, chunkPos, CONFIG); + this.searchPositions = SEARCH_POSITIONS; + } + + @Override + public void findOreVeins(List> veins) { + List starts = new ArrayList<>(); + + for(Set vein: veins) { + if(vein.size() != 8)continue; + + BlockPos oreStart = new BlockPos( + this.findX(vein, OreFinder.HIGHEST), + this.findY(vein, OreFinder.LOWEST) + 3, + this.findZ(vein, OreFinder.HIGHEST) + ); + + starts.add(oreStart); + } + + starts.forEach(start -> { + this.renderers.add(new Cube(start, new Vector4f(0.0f, 1.0f, 1.0f, 1.0f))); + }); + } + + public static List create(World world, ChunkPos chunkPos) { + List finders = new ArrayList<>(); + finders.add(new InfestedStoneOreFinder(world, chunkPos)); + finders.add(new InfestedStoneOreFinder(world, new ChunkPos(chunkPos.x + 1, chunkPos.z))); + finders.add(new InfestedStoneOreFinder(world, new ChunkPos(chunkPos.x, chunkPos.z + 1))); + finders.add(new InfestedStoneOreFinder(world, new ChunkPos(chunkPos.x + 1, chunkPos.z + 1))); + return finders; + } + +} diff --git a/src/main/java/kaptainwutax/seedcracker/finder/OreFinder.java b/src/main/java/kaptainwutax/seedcracker/finder/OreFinder.java new file mode 100644 index 0000000..8d967ca --- /dev/null +++ b/src/main/java/kaptainwutax/seedcracker/finder/OreFinder.java @@ -0,0 +1,205 @@ +package kaptainwutax.seedcracker.finder; + +import kaptainwutax.seedcracker.util.PosIterator; +import net.minecraft.block.BlockState; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.math.Direction; +import net.minecraft.world.World; +import net.minecraft.world.dimension.DimensionType; +import net.minecraft.world.gen.feature.OreFeatureConfig; + +import java.util.*; +import java.util.stream.Collectors; + +public abstract class OreFinder extends BlockFinder { + + public static final int LOWEST = -1; + public static final int HIGHEST = 1; + + protected OreFeatureConfig oreFeatureConfig; + + public OreFinder(World world, ChunkPos chunkPos, OreFeatureConfig oreFeatureConfig) { + super(world, chunkPos, oreFeatureConfig.state); + this.oreFeatureConfig = oreFeatureConfig; + } + + @Override + public final List findInChunk() { + List result = super.findInChunk(); + List> veins = new ArrayList<>(); + + while(!result.isEmpty()) { + Set vein = this.buildVeinRecursively(result.get(0), new HashSet<>()); + vein.forEach(result::remove); + veins.add(vein); + } + + veins.removeIf(vein -> vein.size() > this.oreFeatureConfig.size); + veins.removeIf(vein -> !this.isCompleteVein(vein)); + + this.findOreVeins(veins); + return result; + } + + public Set buildVeinRecursively(BlockPos start, Set progress) { + progress.add(start); + + PosIterator.create(new BlockPos(-1, -1, -1), new BlockPos(1, 1, 1)).forEach(offset -> { + BlockPos pos = start.add(offset); + BlockState state = this.world.getBlockState(pos); + + if(!progress.contains(pos) && state.equals(this.oreFeatureConfig.state)) { + this.buildVeinRecursively(pos, progress); + } + }); + + return progress; + } + + private boolean isCompleteVein(Set vein) { + for(BlockPos pos: vein) { + for(Direction direction: Direction.values()) { + BlockState state = this.world.getBlockState(pos.offset(direction)); + if(!state.equals(this.oreFeatureConfig.state) && + !this.oreFeatureConfig.target.getCondition().test(state))return false; + } + } + + return true; + } + + public boolean canVeinTo(BlockPos b1, BlockPos b2) { + return Math.max(Math.max(Math.abs(b1.getX() - b2.getX()), Math.abs(b1.getY() - b2.getY())), Math.abs(b1.getZ() - b2.getZ())) <= 1; + } + + public int findX(Set vein, int type) { + return getInt(vein.stream().map(BlockPos::getX).collect(Collectors.toList()), type); + } + + public int findY(Set vein, int type) { + return getInt(vein.stream().map(BlockPos::getY).collect(Collectors.toList()), type); + } + + public int findZ(Set vein, int type) { + return getInt(vein.stream().map(BlockPos::getZ).collect(Collectors.toList()), type); + } + + private int getInt(List ints, int type) { + Collections.sort(ints); + return ints.get(type == HIGHEST ? ints.size() - 1 : 0); + } + + public abstract void findOreVeins(List> veins); + + @Override + public boolean isValidDimension(DimensionType dimension) { + return dimension == DimensionType.OVERWORLD; + } + + /* + public boolean method_13628(float piRand, int nextIntA, int nextIntB, BlockPos blockPos_1, OreFeatureConfig oreFeatureConfig_1) { + float float_2 = (float)oreFeatureConfig_1.size / 8.0F; + int int_1 = MathHelper.ceil(((float)oreFeatureConfig_1.size / 16.0F * 2.0F + 1.0F) / 2.0F); + double double_1 = (float)blockPos_1.getX() + MathHelper.sin(piRand) * float_2; + double double_2 = (float)blockPos_1.getX() - MathHelper.sin(piRand) * float_2; + double double_3 = (float)blockPos_1.getZ() + MathHelper.cos(piRand) * float_2; + double double_4 = (float)blockPos_1.getZ() - MathHelper.cos(piRand) * float_2; + double double_5 = blockPos_1.getY() + nextIntA - 2; + double double_6 = blockPos_1.getY() + nextIntB - 2; + int int_3 = blockPos_1.getX() - MathHelper.ceil(float_2) - int_1; + int int_4 = blockPos_1.getY() - 2 - int_1; + int int_5 = blockPos_1.getZ() - MathHelper.ceil(float_2) - int_1; + int int_6 = 2 * (MathHelper.ceil(float_2) + int_1); + int int_7 = 2 * (2 + int_1); + + for(int int_8 = int_3; int_8 <= int_3 + int_6; ++int_8) { + for(int int_9 = int_5; int_9 <= int_5 + int_6; ++int_9) { + return this.generateVeinPart(oreFeatureConfig_1, double_1, double_2, double_3, double_4, double_5, double_6, int_3, int_4, int_5, int_6, int_7); + } + } + + return false; + } + + protected boolean generateVeinPart(OreFeatureConfig oreConfig, double double_1, double double_2, double double_3, double double_4, double double_5, double double_6, int int_1, int int_2, int int_3, int int_4, int int_5) { + int int_6 = 0; + BitSet bitSet_1 = new BitSet(int_4 * int_5 * int_4); + BlockPos.Mutable blockPos$Mutable_1 = new BlockPos.Mutable(); + double[] oreData = new double[oreConfig.size * 4]; + + for(int genStep = 0; genStep < oreConfig.size; ++genStep) { + float genStepProgress = (float)genStep / (float)oreConfig.size; + double xOffset = double_1 + (double_2 - double_1) * genStepProgress; + double yOffset = double_5 + (double_6 - double_5) * genStepProgress; + double zOffset = double_3 + (double_4 - double_3) * genStepProgress; + double genSizeMultiplier = random_1.nextDouble() * (double)oreConfig.size / 16.0D; + double randomBoundOffset = ((double)(MathHelper.sin((float)(Math.PI * genStepProgress)) + 1.0F) * genSizeMultiplier + 1.0D) / 2.0D; + oreData[genStep * 4 + 0] = xOffset; + oreData[genStep * 4 + 1] = yOffset; + oreData[genStep * 4 + 2] = zOffset; + oreData[genStep * 4 + 3] = randomBoundOffset; + } + + for(int genStep = 0; genStep < oreConfig.size - 1; ++genStep) { + if (oreData[genStep * 4 + 3] > 0.0D) { + for(int int_9 = genStep + 1; int_9 < oreConfig.size; ++int_9) { + if (oreData[int_9 * 4 + 3] > 0.0D) { + double xOffset = oreData[genStep * 4 + 0] - oreData[int_9 * 4 + 0]; + double yOffset = oreData[genStep * 4 + 1] - oreData[int_9 * 4 + 1]; + double zOffset = oreData[genStep * 4 + 2] - oreData[int_9 * 4 + 2]; + double genSizeMultiplier = oreData[genStep * 4 + 3] - oreData[int_9 * 4 + 3]; + if (genSizeMultiplier * genSizeMultiplier > xOffset * xOffset + yOffset * yOffset + zOffset * zOffset) { + if (genSizeMultiplier > 0.0D) { + oreData[int_9 * 4 + 3] = -1.0D; + } else { + oreData[genStep * 4 + 3] = -1.0D; + } + } + } + } + } + } + + for(int genStep = 0; genStep < oreConfig.size; ++genStep) { + double randomBoundOffset = oreData[genStep * 4 + 3]; + if (randomBoundOffset < 0.0D)continue; + + double xOffset = oreData[genStep * 4 + 0]; + double yOffset = oreData[genStep * 4 + 1]; + double zOffset = oreData[genStep * 4 + 2]; + int lowerXbound = Math.max(MathHelper.floor(xOffset - randomBoundOffset), int_1); + int lowerYbound = Math.max(MathHelper.floor(yOffset - randomBoundOffset), int_2); + int lowerZbound = Math.max(MathHelper.floor(zOffset - randomBoundOffset), int_3); + int upperXbound = Math.max(MathHelper.floor(xOffset + randomBoundOffset), lowerXbound); + int upperYbound = Math.max(MathHelper.floor(yOffset + randomBoundOffset), lowerYbound); + int upperZbound = Math.max(MathHelper.floor(zOffset + randomBoundOffset), lowerZbound); + + for(int attemptedPosX = lowerXbound; attemptedPosX <= upperXbound; ++attemptedPosX) { + for(int attemptedPosY = lowerYbound; attemptedPosY <= upperYbound; ++attemptedPosY) { + for(int attemptedPosZ = lowerZbound; attemptedPosZ <= upperZbound; ++attemptedPosZ) { + double posX = ((double) attemptedPosX + 0.5D - xOffset) / randomBoundOffset; + double posY = ((double) attemptedPosY + 0.5D - yOffset) / randomBoundOffset; + double posZ = ((double) attemptedPosZ + 0.5D - zOffset) / randomBoundOffset; + boolean posInUnitSphere = posX * posX + posY * posY + posZ * posZ < 1.0D; + + if(posInUnitSphere) { + int int_20 = attemptedPosX - int_1 + (attemptedPosY - int_2) * int_4 + (attemptedPosZ - int_3) * int_4 * int_5; + if (!bitSet_1.get(int_20)) { + bitSet_1.set(int_20); + blockPos$Mutable_1.set(attemptedPosX, attemptedPosY, attemptedPosZ); + if (oreConfig.target.getCondition().test(iWorld_1.getBlockState(blockPos$Mutable_1))) { + iWorld_1.setBlockState(blockPos$Mutable_1, oreConfig.state, 2); + ++int_6; + } + } + } + } + } + } + } + + return int_6 > 0; + }*/ + +}