Tags, surface builders, biome API (WIP), processors, features
This commit is contained in:
paulevsGitch
parent
6b0bf593ad
commit
979e2ab92a
15 changed files with 1513 additions and 51 deletions
|
|
@ -1,14 +1,15 @@
|
|||
package ru.bclib.util;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.Random;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
import net.minecraft.core.BlockPos;
|
||||
import net.minecraft.core.BlockPos.MutableBlockPos;
|
||||
import net.minecraft.core.Direction;
|
||||
import net.minecraft.core.Vec3i;
|
||||
import net.minecraft.world.level.BlockGetter;
|
||||
import net.minecraft.world.level.ClipContext.Fluid;
|
||||
import net.minecraft.world.level.LevelAccessor;
|
||||
import net.minecraft.world.level.block.Block;
|
||||
import net.minecraft.world.level.block.Blocks;
|
||||
|
|
@ -37,20 +38,6 @@ public class BlocksHelper {
|
|||
protected static final BlockState AIR = Blocks.AIR.defaultBlockState();
|
||||
protected static final BlockState WATER = Blocks.WATER.defaultBlockState();
|
||||
|
||||
private static final Vec3i[] OFFSETS = new Vec3i[] {
|
||||
new Vec3i(-1, -1, -1), new Vec3i(-1, -1, 0), new Vec3i(-1, -1, 1),
|
||||
new Vec3i(-1, 0, -1), new Vec3i(-1, 0, 0), new Vec3i(-1, 0, 1),
|
||||
new Vec3i(-1, 1, -1), new Vec3i(-1, 1, 0), new Vec3i(-1, 1, 1),
|
||||
|
||||
new Vec3i(0, -1, -1), new Vec3i(0, -1, 0), new Vec3i(0, -1, 1),
|
||||
new Vec3i(0, 0, -1), new Vec3i(0, 0, 0), new Vec3i(0, 0, 1),
|
||||
new Vec3i(0, 1, -1), new Vec3i(0, 1, 0), new Vec3i(0, 1, 1),
|
||||
|
||||
new Vec3i(1, -1, -1), new Vec3i(1, -1, 0), new Vec3i(1, -1, 1),
|
||||
new Vec3i(1, 0, -1), new Vec3i(1, 0, 0), new Vec3i(1, 0, 1),
|
||||
new Vec3i(1, 1, -1), new Vec3i(1, 1, 0), new Vec3i(1, 1, 1)
|
||||
};
|
||||
|
||||
public static void addBlockColor(Block block, int color) {
|
||||
COLOR_BY_BLOCK.put(block, color);
|
||||
}
|
||||
|
|
@ -107,14 +94,35 @@ public class BlocksHelper {
|
|||
return (int) pos.distSqr(POS);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotates {@link BlockState} horizontally. Used in block classes with {@link Direction} {@link Property} in rotate function.
|
||||
* @param state - {@link BlockState} to mirror;
|
||||
* @param rotation - {@link Rotation};
|
||||
* @param facing - Block {@link Direction} {@link Property}.
|
||||
* @return Rotated {@link BlockState}.
|
||||
*/
|
||||
public static BlockState rotateHorizontal(BlockState state, Rotation rotation, Property<Direction> facing) {
|
||||
return state.setValue(facing, rotation.rotate(state.getValue(facing)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Mirrors {@link BlockState} horizontally. Used in block classes with {@link Direction} {@link Property} in mirror function.
|
||||
* @param state - {@link BlockState} to mirror;
|
||||
* @param mirror - {@link Mirror};
|
||||
* @param facing - Block {@link Direction} {@link Property}.
|
||||
* @return Mirrored {@link BlockState}.
|
||||
*/
|
||||
public static BlockState mirrorHorizontal(BlockState state, Mirror mirror, Property<Direction> facing) {
|
||||
return state.rotate(mirror.getRotation(state.getValue(facing)));
|
||||
}
|
||||
|
||||
/**
|
||||
* Counts the amount of same block down.
|
||||
* @param world - {@link LevelAccessor} world;
|
||||
* @param pos - {@link BlockPos} start position;
|
||||
* @param block - {@link Block} to count.
|
||||
* @return Integer amount of blocks.
|
||||
*/
|
||||
public static int getLengthDown(LevelAccessor world, BlockPos pos, Block block) {
|
||||
int count = 1;
|
||||
while (world.getBlockState(pos.below(count)).getBlock() == block) {
|
||||
|
|
@ -123,49 +131,59 @@ public class BlocksHelper {
|
|||
return count;
|
||||
}
|
||||
|
||||
public static void cover(LevelAccessor world, BlockPos center, Block ground, BlockState cover, int radius, Random random) {
|
||||
HashSet<BlockPos> points = new HashSet<BlockPos>();
|
||||
HashSet<BlockPos> points2 = new HashSet<BlockPos>();
|
||||
if (world.getBlockState(center).getBlock() == ground) {
|
||||
points.add(center);
|
||||
points2.add(center);
|
||||
for (int i = 0; i < radius; i++) {
|
||||
Iterator<BlockPos> iterator = points.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
BlockPos pos = iterator.next();
|
||||
for (Vec3i offset : OFFSETS) {
|
||||
if (random.nextBoolean()) {
|
||||
BlockPos pos2 = pos.offset(offset);
|
||||
if (random.nextBoolean() && world.getBlockState(pos2).getBlock() == ground
|
||||
&& !points.contains(pos2))
|
||||
points2.add(pos2);
|
||||
}
|
||||
}
|
||||
}
|
||||
points.addAll(points2);
|
||||
points2.clear();
|
||||
}
|
||||
Iterator<BlockPos> iterator = points.iterator();
|
||||
while (iterator.hasNext()) {
|
||||
BlockPos pos = iterator.next();
|
||||
BlocksHelper.setWithoutUpdate(world, pos, cover);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new {@link Direction} array with clockwise order:
|
||||
* NORTH -> EAST -> SOUTH -> WEST
|
||||
* @return Array of {@link Direction}.
|
||||
*/
|
||||
public static Direction[] makeHorizontal() {
|
||||
return new Direction[] { Direction.NORTH, Direction.EAST, Direction.SOUTH, Direction.WEST };
|
||||
}
|
||||
|
||||
/**
|
||||
* Get any random horizontal {@link Direction}.
|
||||
* @param random - {@link Random}.
|
||||
* @return {@link Direction}.
|
||||
*/
|
||||
public static Direction randomHorizontal(Random random) {
|
||||
return HORIZONTAL[random.nextInt(4)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Get any random {@link Direction} including vertical and horizontal.
|
||||
* @param random - {@link Random}.
|
||||
* @return {@link Direction}.
|
||||
*/
|
||||
public static Direction randomDirection(Random random) {
|
||||
return DIRECTIONS[random.nextInt(6)];
|
||||
}
|
||||
|
||||
public static boolean isFluid(BlockState blockState) {
|
||||
return !blockState.getFluidState().isEmpty();
|
||||
/**
|
||||
* Check if block is {@link Fluid} or not.
|
||||
* @param state - {@link BlockState} to check.
|
||||
* @return {@code true} if block is fluid and {@code false} if not.
|
||||
*/
|
||||
public static boolean isFluid(BlockState state) {
|
||||
return !state.getFluidState().isEmpty();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if block is "invulnerable" like Bedrock.
|
||||
* @param state - {@link BlockState} to check;
|
||||
* @param world - {@link BlockGetter} world where BlockState exist;
|
||||
* @param pos - {@link BlockPos} where BlockState is.
|
||||
* @return {@code true} if block is "invulnerable" and {@code false} if not.
|
||||
*/
|
||||
public static boolean isInvulnerable(BlockState state, BlockGetter world, BlockPos pos) {
|
||||
return state.getDestroySpeed(world, pos) < 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if block is "invulnerable" like Bedrock. Unlike safe function will pass world and position parameters as {@code null}.
|
||||
* @param state - {@link BlockState} to check.
|
||||
* @return {@code true} if block is "invulnerable" and {@code false} if not.
|
||||
*/
|
||||
public static boolean isInvulnerableUnsafe(BlockState state) {
|
||||
return isInvulnerable(state, null, null);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
372
src/main/java/ru/bclib/util/StructureHelper.java
Normal file
372
src/main/java/ru/bclib/util/StructureHelper.java
Normal file
|
|
@ -0,0 +1,372 @@
|
|||
package ru.bclib.util;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.util.Enumeration;
|
||||
import java.util.Random;
|
||||
import java.util.Set;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipFile;
|
||||
|
||||
import com.google.common.collect.Sets;
|
||||
|
||||
import net.minecraft.core.BlockPos;
|
||||
import net.minecraft.core.Direction;
|
||||
import net.minecraft.core.BlockPos.MutableBlockPos;
|
||||
import net.minecraft.nbt.CompoundTag;
|
||||
import net.minecraft.nbt.NbtIo;
|
||||
import net.minecraft.resources.ResourceLocation;
|
||||
import net.minecraft.tags.BlockTags;
|
||||
import net.minecraft.world.level.WorldGenLevel;
|
||||
import net.minecraft.world.level.block.Blocks;
|
||||
import net.minecraft.world.level.block.Mirror;
|
||||
import net.minecraft.world.level.block.Rotation;
|
||||
import net.minecraft.world.level.block.state.BlockState;
|
||||
import net.minecraft.world.level.levelgen.structure.BoundingBox;
|
||||
import net.minecraft.world.level.levelgen.structure.templatesystem.StructurePlaceSettings;
|
||||
import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplate;
|
||||
import net.minecraft.world.level.material.Material;
|
||||
import ru.bclib.api.BCLibTags;
|
||||
|
||||
public class StructureHelper {
|
||||
private static final Direction[] DIR = BlocksHelper.makeHorizontal();
|
||||
|
||||
public static StructureTemplate readStructure(ResourceLocation resource) {
|
||||
String ns = resource.getNamespace();
|
||||
String nm = resource.getPath();
|
||||
return readStructure("/data/" + ns + "/structures/" + nm + ".nbt");
|
||||
}
|
||||
|
||||
public static StructureTemplate readStructure(File datapack, String path) {
|
||||
if (datapack.isDirectory()) {
|
||||
return readStructure(datapack.toString() + "/" + path);
|
||||
}
|
||||
else if (datapack.isFile() && datapack.getName().endsWith(".zip")) {
|
||||
try {
|
||||
ZipFile zipFile = new ZipFile(datapack);
|
||||
Enumeration<? extends ZipEntry> entries = zipFile.entries();
|
||||
while (entries.hasMoreElements()) {
|
||||
ZipEntry entry = entries.nextElement();
|
||||
String name = entry.getName();
|
||||
long compressedSize = entry.getCompressedSize();
|
||||
long normalSize = entry.getSize();
|
||||
String type = entry.isDirectory() ? "DIR" : "FILE";
|
||||
|
||||
System.out.println(name);
|
||||
System.out.format("\t %s - %d - %d\n", type, compressedSize, normalSize);
|
||||
}
|
||||
zipFile.close();
|
||||
}
|
||||
catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static StructureTemplate readStructure(String path) {
|
||||
try {
|
||||
InputStream inputstream = StructureHelper.class.getResourceAsStream(path);
|
||||
return readStructureFromStream(inputstream);
|
||||
}
|
||||
catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static StructureTemplate readStructureFromStream(InputStream stream) throws IOException {
|
||||
CompoundTag nbttagcompound = NbtIo.readCompressed(stream);
|
||||
|
||||
StructureTemplate template = new StructureTemplate();
|
||||
template.load(nbttagcompound);
|
||||
|
||||
return template;
|
||||
}
|
||||
|
||||
public static BlockPos offsetPos(BlockPos pos, StructureTemplate structure, Rotation rotation, Mirror mirror) {
|
||||
BlockPos offset = StructureTemplate.transform(structure.getSize(), mirror, rotation, BlockPos.ZERO);
|
||||
return pos.offset(-offset.getX() * 0.5, 0, -offset.getZ() * 0.5);
|
||||
}
|
||||
|
||||
public static void placeCenteredBottom(WorldGenLevel world, BlockPos pos, StructureTemplate structure, Rotation rotation, Mirror mirror, Random random) {
|
||||
placeCenteredBottom(world, pos, structure, rotation, mirror, makeBox(pos), random);
|
||||
}
|
||||
|
||||
public static void placeCenteredBottom(WorldGenLevel world, BlockPos pos, StructureTemplate structure, Rotation rotation, Mirror mirror, BoundingBox bounds, Random random) {
|
||||
BlockPos offset = offsetPos(pos, structure, rotation, mirror);
|
||||
StructurePlaceSettings placementData = new StructurePlaceSettings().setRotation(rotation).setMirror(mirror).setBoundingBox(bounds);
|
||||
structure.placeInWorldChunk(world, offset, placementData, random);
|
||||
}
|
||||
|
||||
private static BoundingBox makeBox(BlockPos pos) {
|
||||
int sx = ((pos.getX() >> 4) << 4) - 16;
|
||||
int sz = ((pos.getZ() >> 4) << 4) - 16;
|
||||
int ex = sx + 47;
|
||||
int ez = sz + 47;
|
||||
return BoundingBox.createProper(sx, 0, sz, ex, 255, ez);
|
||||
}
|
||||
|
||||
public static BoundingBox getStructureBounds(BlockPos pos, StructureTemplate structure, Rotation rotation, Mirror mirror) {
|
||||
BlockPos max = structure.getSize();
|
||||
BlockPos min = StructureTemplate.transform(structure.getSize(), mirror, rotation, BlockPos.ZERO);
|
||||
max = max.subtract(min);
|
||||
return new BoundingBox(min.offset(pos), max.offset(pos));
|
||||
}
|
||||
|
||||
public static BoundingBox intersectBoxes(BoundingBox box1, BoundingBox box2) {
|
||||
int x1 = MHelper.max(box1.x0, box2.x0);
|
||||
int y1 = MHelper.max(box1.y0, box2.y0);
|
||||
int z1 = MHelper.max(box1.z0, box2.z0);
|
||||
|
||||
int x2 = MHelper.min(box1.x1, box2.x1);
|
||||
int y2 = MHelper.min(box1.y1, box2.y1);
|
||||
int z2 = MHelper.min(box1.z1, box2.z1);
|
||||
|
||||
return BoundingBox.createProper(x1, y1, z1, x2, y2, z2);
|
||||
}
|
||||
|
||||
public static void erode(WorldGenLevel world, BoundingBox bounds, int iterations, Random random) {
|
||||
MutableBlockPos mut = new MutableBlockPos();
|
||||
boolean canDestruct = true;
|
||||
for (int i = 0; i < iterations; i++) {
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
for (int y = bounds.y1; y >= bounds.y0; y--) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (canDestruct && BlocksHelper.isInvulnerableUnsafe(state) && random.nextInt(8) == 0 && world.isEmptyBlock(mut.below(2))) {
|
||||
int r = MHelper.randRange(1, 4, random);
|
||||
int cx = mut.getX();
|
||||
int cy = mut.getY();
|
||||
int cz = mut.getZ();
|
||||
int x1 = cx - r;
|
||||
int y1 = cy - r;
|
||||
int z1 = cz - r;
|
||||
int x2 = cx + r;
|
||||
int y2 = cy + r;
|
||||
int z2 = cz + r;
|
||||
for (int px = x1; px <= x2; px++) {
|
||||
int dx = px - cx;
|
||||
dx *= dx;
|
||||
mut.setX(px);
|
||||
for (int py = y1; py <= y2; py++) {
|
||||
int dy = py - cy;
|
||||
dy *= dy;
|
||||
mut.setY(py);
|
||||
for (int pz = z1; pz <= z2; pz++) {
|
||||
int dz = pz - cz;
|
||||
dz *= dz;
|
||||
mut.setZ(pz);
|
||||
if (dx + dy + dz <= r && BlocksHelper.isInvulnerableUnsafe(world.getBlockState(mut))) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
mut.setX(cx);
|
||||
mut.setY(cy);
|
||||
mut.setZ(cz);
|
||||
canDestruct = false;
|
||||
continue;
|
||||
}
|
||||
else if (ignore(state)) {
|
||||
continue;
|
||||
}
|
||||
if (!state.isAir() && random.nextBoolean()) {
|
||||
MHelper.shuffle(DIR, random);
|
||||
for (Direction dir: DIR) {
|
||||
if (world.isEmptyBlock(mut.relative(dir)) && world.isEmptyBlock(mut.below().relative(dir))) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
mut.move(dir).move(Direction.DOWN);
|
||||
for (int py = mut.getY(); y >= bounds.y0 - 10; y--) {
|
||||
mut.setY(py - 1);
|
||||
if (!world.isEmptyBlock(mut)) {
|
||||
mut.setY(py);
|
||||
BlocksHelper.setWithoutUpdate(world, mut, state);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
else if (random.nextInt(8) == 0 && !BlocksHelper.isInvulnerableUnsafe(world.getBlockState(mut.above()))) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
for (int y = bounds.y1; y >= bounds.y0; y--) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (!ignore(state) && world.isEmptyBlock(mut.below())) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
for (int py = mut.getY(); py >= bounds.y0 - 10; py--) {
|
||||
mut.setY(py - 1);
|
||||
if (!world.isEmptyBlock(mut)) {
|
||||
mut.setY(py);
|
||||
BlocksHelper.setWithoutUpdate(world, mut, state);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static void erodeIntense(WorldGenLevel world, BoundingBox bounds, Random random) {
|
||||
MutableBlockPos mut = new MutableBlockPos();
|
||||
MutableBlockPos mut2 = new MutableBlockPos();
|
||||
int minY = bounds.y0 - 10;
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
for (int y = bounds.y1; y >= bounds.y0; y--) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (!ignore(state)) {
|
||||
if (random.nextInt(6) == 0) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
if (random.nextBoolean()) {
|
||||
int px = MHelper.floor(random.nextGaussian() * 2 + x + 0.5);
|
||||
int pz = MHelper.floor(random.nextGaussian() * 2 + z + 0.5);
|
||||
mut2.set(px, y, pz);
|
||||
while (world.getBlockState(mut2).getMaterial().isReplaceable() && mut2.getY() > minY) {
|
||||
mut2.setY(mut2.getY() - 1);
|
||||
}
|
||||
if (!world.getBlockState(mut2).isAir() && state.canSurvive(world, mut2)) {
|
||||
mut2.setY(mut2.getY() + 1);
|
||||
BlocksHelper.setWithoutUpdate(world, mut2, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (random.nextInt(8) == 0) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
drop(world, bounds);
|
||||
}
|
||||
|
||||
private static boolean isTerrainNear(WorldGenLevel world, BlockPos pos) {
|
||||
for (Direction dir: BlocksHelper.DIRECTIONS) {
|
||||
if (world.getBlockState(pos.relative(dir)).is(BCLibTags.GEN_TERRAIN)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private static void drop(WorldGenLevel world, BoundingBox bounds) {
|
||||
MutableBlockPos mut = new MutableBlockPos();
|
||||
|
||||
Set<BlockPos> blocks = Sets.newHashSet();
|
||||
Set<BlockPos> edge = Sets.newHashSet();
|
||||
Set<BlockPos> add = Sets.newHashSet();
|
||||
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
for (int y = bounds.y0; y <= bounds.y1; y++) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (!ignore(state) && isTerrainNear(world, mut)) {
|
||||
edge.add(mut.immutable());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (edge.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
while (!edge.isEmpty()) {
|
||||
for (BlockPos center: edge) {
|
||||
for (Direction dir: BlocksHelper.DIRECTIONS) {
|
||||
BlockState state = world.getBlockState(center);
|
||||
if (state.isCollisionShapeFullBlock(world, center)) {
|
||||
mut.set(center).move(dir);
|
||||
if (bounds.isInside(mut)) {
|
||||
state = world.getBlockState(mut);
|
||||
if (!ignore(state) && !blocks.contains(mut)) {
|
||||
add.add(mut.immutable());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
blocks.addAll(edge);
|
||||
edge.clear();
|
||||
edge.addAll(add);
|
||||
add.clear();
|
||||
}
|
||||
|
||||
int minY = bounds.y0 - 10;
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
for (int y = bounds.y0; y <= bounds.y1; y++) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (!ignore(state) && !blocks.contains(mut)) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, Blocks.AIR);
|
||||
while (world.getBlockState(mut).getMaterial().isReplaceable() && mut.getY() > minY) {
|
||||
mut.setY(mut.getY() - 1);
|
||||
}
|
||||
if (mut.getY() > minY) {
|
||||
mut.setY(mut.getY() + 1);
|
||||
BlocksHelper.setWithoutUpdate(world, mut, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean ignore(BlockState state) {
|
||||
return state.getMaterial().isReplaceable() ||
|
||||
!state.getFluidState().isEmpty() ||
|
||||
state.is(BCLibTags.END_GROUND) ||
|
||||
state.is(BlockTags.LOGS) ||
|
||||
state.is(BlockTags.LEAVES) ||
|
||||
state.getMaterial().equals(Material.PLANT) ||
|
||||
state.getMaterial().equals(Material.LEAVES) ||
|
||||
BlocksHelper.isInvulnerableUnsafe(state);
|
||||
}
|
||||
|
||||
public static void cover(WorldGenLevel world, BoundingBox bounds, Random random) {
|
||||
MutableBlockPos mut = new MutableBlockPos();
|
||||
for (int x = bounds.x0; x <= bounds.x1; x++) {
|
||||
mut.setX(x);
|
||||
for (int z = bounds.z0; z <= bounds.z1; z++) {
|
||||
mut.setZ(z);
|
||||
BlockState top = world.getBiome(mut).getGenerationSettings().getSurfaceBuilderConfig().getTopMaterial();
|
||||
for (int y = bounds.y1; y >= bounds.y0; y--) {
|
||||
mut.setY(y);
|
||||
BlockState state = world.getBlockState(mut);
|
||||
if (state.is(BCLibTags.END_GROUND) && !world.getBlockState(mut.above()).getMaterial().isSolidBlocking()) {
|
||||
BlocksHelper.setWithoutUpdate(world, mut, top);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue