From 3b7c5099b840f0ddc22b4c43d83106c3d57a4e34 Mon Sep 17 00:00:00 2001 From: dags- Date: Tue, 3 Mar 2020 20:38:55 +0000 Subject: [PATCH] - subclass WorldGenRegion for the feature placement wrapper (provides compat for mods that rely on it being a WorldGenRegion instance) - don't extend trees downwards when bonemealed or grown naturally - update forge version on FeatureManager repo --- .../mod/chunk/TerraChunkGenerator.java | 1 - .../mod/chunk/fix/RegionDelegate.java | 593 ++++++++++++++++++ .../terraforged/mod/chunk/fix/RegionFix.java | 7 +- .../mod/feature/tree/SaplingPlacer.java | 14 +- .../{TreeBuffer.java => TreeGrowBuffer.java} | 7 +- gradle.properties | 2 +- 6 files changed, 609 insertions(+), 15 deletions(-) create mode 100644 TerraForgedMod/src/main/java/com/terraforged/mod/chunk/fix/RegionDelegate.java rename TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/{TreeBuffer.java => TreeGrowBuffer.java} (95%) diff --git a/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/TerraChunkGenerator.java b/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/TerraChunkGenerator.java index 76d04e9..4f62713 100644 --- a/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/TerraChunkGenerator.java +++ b/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/TerraChunkGenerator.java @@ -187,7 +187,6 @@ public class TerraChunkGenerator extends ObfHelperChunkGenerator predicate) { + return region.getClosestPlayer(x, y, z, distance, predicate); + } + + @Override + public int getSkylightSubtracted() { + return region.getSkylightSubtracted(); + } + + @Override + public BiomeManager func_225523_d_() { + return region.func_225523_d_(); + } + + @Override + public Biome getNoiseBiomeRaw(int x, int y, int z) { + return region.getNoiseBiomeRaw(x, y, z); + } + + @Override + public WorldLightManager getLightManager() { + return region.getLightManager(); + } + + @Override + public boolean func_225521_a_(BlockPos p_225521_1_, boolean p_225521_2_, @Nullable Entity p_225521_3_) { + return region.func_225521_a_(p_225521_1_, p_225521_2_, p_225521_3_); + } + + @Override + @Nullable + public TileEntity getTileEntity(BlockPos pos) { + return region.getTileEntity(pos); + } + + @Override + public boolean setBlockState(BlockPos pos, BlockState newState, int flags) { + return region.setBlockState(pos, newState, flags); + } + + @Override + public boolean addEntity(Entity entityIn) { + return region.addEntity(entityIn); + } + + @Override + public boolean removeBlock(BlockPos pos, boolean isMoving) { + return region.removeBlock(pos, isMoving); + } + + @Override + public WorldBorder getWorldBorder() { + return region.getWorldBorder(); + } + + @Override + public boolean isRemote() { + return region.isRemote(); + } + + @Override + @Deprecated + public ServerWorld getWorld() { + return region.getWorld(); + } + + @Override + public WorldInfo getWorldInfo() { + return region.getWorldInfo(); + } + + @Override + public DifficultyInstance getDifficultyForLocation(BlockPos pos) { + return region.getDifficultyForLocation(pos); + } + + @Override + public AbstractChunkProvider getChunkProvider() { + return region.getChunkProvider(); + } + + @Override + public long getSeed() { + return region.getSeed(); + } + + @Override + public ITickList getPendingBlockTicks() { + return region.getPendingBlockTicks(); + } + + @Override + public ITickList getPendingFluidTicks() { + return region.getPendingFluidTicks(); + } + + @Override + public int getSeaLevel() { + return region.getSeaLevel(); + } + + @Override + public Random getRandom() { + return region.getRandom(); + } + + @Override + public void notifyNeighbors(BlockPos pos, Block blockIn) { + region.notifyNeighbors(pos, blockIn); + } + + @Override + public int getHeight(Heightmap.Type heightmapType, int x, int z) { + return region.getHeight(heightmapType, x, z); + } + + @Override + public void playSound(@Nullable PlayerEntity player, BlockPos pos, SoundEvent soundIn, SoundCategory category, float volume, float pitch) { + region.playSound(player, pos, soundIn, category, volume, pitch); + } + + @Override + public void addParticle(IParticleData particleData, double x, double y, double z, double xSpeed, double ySpeed, double zSpeed) { + region.addParticle(particleData, x, y, z, xSpeed, ySpeed, zSpeed); + } + + @Override + public void playEvent(@Nullable PlayerEntity player, int type, BlockPos pos, int data) { + region.playEvent(player, type, pos, data); + } + + @Override + @OnlyIn(Dist.CLIENT) + public BlockPos getSpawnPoint() { + return region.getSpawnPoint(); + } + + @Override + public Dimension getDimension() { + return region.getDimension(); + } + + @Override + public boolean hasBlockState(BlockPos p_217375_1_, Predicate p_217375_2_) { + return region.hasBlockState(p_217375_1_, p_217375_2_); + } + + @Override + public List getEntitiesWithinAABB(Class clazz, AxisAlignedBB aabb, @Nullable Predicate filter) { + return region.getEntitiesWithinAABB(clazz, aabb, filter); + } + + @Override + public List getEntitiesInAABBexcluding(@Nullable Entity entityIn, AxisAlignedBB boundingBox, @Nullable Predicate predicate) { + return region.getEntitiesInAABBexcluding(entityIn, boundingBox, predicate); + } + + @Override + public List getPlayers() { + return region.getPlayers(); + } + + @Override + public float getCurrentMoonPhaseFactor() { + return region.getCurrentMoonPhaseFactor(); + } + + @Override + public float getCelestialAngle(float partialTicks) { + return region.getCelestialAngle(partialTicks); + } + + @Override + @OnlyIn(Dist.CLIENT) + public int getMoonPhase() { + return region.getMoonPhase(); + } + + @Override + public Difficulty getDifficulty() { + return region.getDifficulty(); + } + + @Override + public void playEvent(int type, BlockPos pos, int data) { + region.playEvent(type, pos, data); + } + + @Override + public Stream getEmptyCollisionShapes(@Nullable Entity entityIn, AxisAlignedBB aabb, Set entitiesToIgnore) { + return region.getEmptyCollisionShapes(entityIn, aabb, entitiesToIgnore); + } + + @Override + public boolean checkNoEntityCollision(@Nullable Entity entityIn, VoxelShape shape) { + return region.checkNoEntityCollision(entityIn, shape); + } + + @Override + public BlockPos getHeight(Heightmap.Type heightmapType, BlockPos pos) { + return region.getHeight(heightmapType, pos); + } + + @Override + public List func_225316_b(Class p_225316_1_, AxisAlignedBB p_225316_2_, @Nullable Predicate p_225316_3_) { + return region.func_225316_b(p_225316_1_, p_225316_2_, p_225316_3_); + } + + @Override + public List getEntitiesWithinAABBExcludingEntity(@Nullable Entity entityIn, AxisAlignedBB bb) { + return region.getEntitiesWithinAABBExcludingEntity(entityIn, bb); + } + + @Override + public List getEntitiesWithinAABB(Class p_217357_1_, AxisAlignedBB p_217357_2_) { + return region.getEntitiesWithinAABB(p_217357_1_, p_217357_2_); + } + + @Override + public List func_225317_b(Class p_225317_1_, AxisAlignedBB p_225317_2_) { + return region.func_225317_b(p_225317_1_, p_225317_2_); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(Entity entityIn, double distance) { + return region.getClosestPlayer(entityIn, distance); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(double x, double y, double z, double distance, boolean creativePlayers) { + return region.getClosestPlayer(x, y, z, distance, creativePlayers); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(double x, double y, double z) { + return region.getClosestPlayer(x, y, z); + } + + @Override + public boolean isPlayerWithin(double x, double y, double z, double distance) { + return region.isPlayerWithin(x, y, z, distance); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(EntityPredicate predicate, LivingEntity target) { + return region.getClosestPlayer(predicate, target); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(EntityPredicate predicate, LivingEntity target, double p_217372_3_, double p_217372_5_, double p_217372_7_) { + return region.getClosestPlayer(predicate, target, p_217372_3_, p_217372_5_, p_217372_7_); + } + + @Override + @Nullable + public PlayerEntity getClosestPlayer(EntityPredicate predicate, double x, double y, double z) { + return region.getClosestPlayer(predicate, x, y, z); + } + + @Override + @Nullable + public T getClosestEntityWithinAABB(Class entityClazz, EntityPredicate p_217360_2_, @Nullable LivingEntity target, double x, double y, double z, AxisAlignedBB boundingBox) { + return region.getClosestEntityWithinAABB(entityClazz, p_217360_2_, target, x, y, z, boundingBox); + } + + @Override + @Nullable + public T func_225318_b(Class p_225318_1_, EntityPredicate p_225318_2_, @Nullable LivingEntity p_225318_3_, double p_225318_4_, double p_225318_6_, double p_225318_8_, AxisAlignedBB p_225318_10_) { + return region.func_225318_b(p_225318_1_, p_225318_2_, p_225318_3_, p_225318_4_, p_225318_6_, p_225318_8_, p_225318_10_); + } + + @Override + @Nullable + public T getClosestEntity(List entities, EntityPredicate predicate, @Nullable LivingEntity target, double x, double y, double z) { + return region.getClosestEntity(entities, predicate, target, x, y, z); + } + + @Override + public List getTargettablePlayersWithinAABB(EntityPredicate predicate, LivingEntity target, AxisAlignedBB box) { + return region.getTargettablePlayersWithinAABB(predicate, target, box); + } + + @Override + public List getTargettableEntitiesWithinAABB(Class p_217374_1_, EntityPredicate p_217374_2_, LivingEntity p_217374_3_, AxisAlignedBB p_217374_4_) { + return region.getTargettableEntitiesWithinAABB(p_217374_1_, p_217374_2_, p_217374_3_, p_217374_4_); + } + + @Override + @Nullable + public PlayerEntity getPlayerByUuid(UUID uniqueIdIn) { + return region.getPlayerByUuid(uniqueIdIn); + } + + @Override + public Biome getBiome(BlockPos p_226691_1_) { + return region.getBiome(p_226691_1_); + } + + @Override + @OnlyIn(Dist.CLIENT) + public int getBlockColor(BlockPos blockPosIn, ColorResolver colorResolverIn) { + return region.getBlockColor(blockPosIn, colorResolverIn); + } + + @Override + public Biome getNoiseBiome(int x, int y, int z) { + return region.getNoiseBiome(x, y, z); + } + + @Override + public boolean isAirBlock(BlockPos pos) { + return region.isAirBlock(pos); + } + + @Override + public boolean canBlockSeeSky(BlockPos pos) { + return region.canBlockSeeSky(pos); + } + + @Override + @Deprecated + public float getBrightness(BlockPos pos) { + return region.getBrightness(pos); + } + + @Override + public int getStrongPower(BlockPos pos, Direction direction) { + return region.getStrongPower(pos, direction); + } + + @Override + public IChunk getChunk(BlockPos pos) { + return region.getChunk(pos); + } + + @Override + public IChunk getChunk(int chunkX, int chunkZ, ChunkStatus requiredStatus) { + return region.getChunk(chunkX, chunkZ, requiredStatus); + } + + @Override + @Nullable + public IBlockReader getBlockReader(int p_225522_1_, int p_225522_2_) { + return region.getBlockReader(p_225522_1_, p_225522_2_); + } + + @Override + public boolean hasWater(BlockPos pos) { + return region.hasWater(pos); + } + + @Override + public boolean containsAnyLiquid(AxisAlignedBB bb) { + return region.containsAnyLiquid(bb); + } + + @Override + public int getLight(BlockPos pos) { + return region.getLight(pos); + } + + @Override + public int getNeighborAwareLightSubtracted(BlockPos pos, int amount) { + return region.getNeighborAwareLightSubtracted(pos, amount); + } + + @Override + @Deprecated + public boolean isBlockLoaded(BlockPos pos) { + return region.isBlockLoaded(pos); + } + + @Override + public boolean isAreaLoaded(BlockPos center, int range) { + return region.isAreaLoaded(center, range); + } + + @Override + @Deprecated + public boolean isAreaLoaded(BlockPos from, BlockPos to) { + return region.isAreaLoaded(from, to); + } + + @Override + @Deprecated + public boolean isAreaLoaded(int fromX, int fromY, int fromZ, int toX, int toY, int toZ) { + return region.isAreaLoaded(fromX, fromY, fromZ, toX, toY, toZ); + } + + @Override + public int getLightFor(LightType lightTypeIn, BlockPos blockPosIn) { + return region.getLightFor(lightTypeIn, blockPosIn); + } + + @Override + public int getLightSubtracted(BlockPos blockPosIn, int amount) { + return region.getLightSubtracted(blockPosIn, amount); + } + + @Override + public boolean canSeeSky(BlockPos blockPosIn) { + return region.canSeeSky(blockPosIn); + } + + @Override + public int getLightValue(BlockPos pos) { + return region.getLightValue(pos); + } + + @Override + public int getMaxLightLevel() { + return region.getMaxLightLevel(); + } + + @Override + public int getHeight() { + return region.getHeight(); + } + + @Override + public BlockRayTraceResult rayTraceBlocks(RayTraceContext context) { + return region.rayTraceBlocks(context); + } + + @Override + @Nullable + public BlockRayTraceResult rayTraceBlocks(Vec3d p_217296_1_, Vec3d p_217296_2_, BlockPos p_217296_3_, VoxelShape p_217296_4_, BlockState p_217296_5_) { + return region.rayTraceBlocks(p_217296_1_, p_217296_2_, p_217296_3_, p_217296_4_, p_217296_5_); + } + + @Override + public boolean func_226663_a_(BlockState p_226663_1_, BlockPos p_226663_2_, ISelectionContext p_226663_3_) { + return region.func_226663_a_(p_226663_1_, p_226663_2_, p_226663_3_); + } + + @Override + public boolean func_226668_i_(Entity p_226668_1_) { + return region.func_226668_i_(p_226668_1_); + } + + @Override + public boolean func_226664_a_(AxisAlignedBB p_226664_1_) { + return region.func_226664_a_(p_226664_1_); + } + + @Override + public boolean func_226669_j_(Entity p_226669_1_) { + return region.func_226669_j_(p_226669_1_); + } + + @Override + public boolean func_226665_a__(Entity p_226665_1_, AxisAlignedBB p_226665_2_) { + return region.func_226665_a__(p_226665_1_, p_226665_2_); + } + + @Override + public boolean func_226662_a_(@Nullable Entity p_226662_1_, AxisAlignedBB p_226662_2_, Set p_226662_3_) { + return region.func_226662_a_(p_226662_1_, p_226662_2_, p_226662_3_); + } + + @Override + public Stream func_226667_c_(@Nullable Entity p_226667_1_, AxisAlignedBB p_226667_2_, Set p_226667_3_) { + return region.func_226667_c_(p_226667_1_, p_226667_2_, p_226667_3_); + } + + @Override + public Stream func_226666_b_(@Nullable Entity p_226666_1_, AxisAlignedBB p_226666_2_) { + return region.func_226666_b_(p_226666_1_, p_226666_2_); + } + + @Override + public int getMaxHeight() { + return region.getMaxHeight(); + } + + @Override + public boolean destroyBlock(BlockPos pos, boolean dropBlock) { + return region.destroyBlock(pos, dropBlock); + } + + private static IChunk getMainChunk(WorldGenRegion region) { + int x = region.getMainChunkX(); + int z = region.getMainChunkZ(); + return region.getChunk(x, z); + } +} diff --git a/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/fix/RegionFix.java b/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/fix/RegionFix.java index 9ba2e19..2a96c20 100644 --- a/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/fix/RegionFix.java +++ b/TerraForgedMod/src/main/java/com/terraforged/mod/chunk/fix/RegionFix.java @@ -25,7 +25,6 @@ package com.terraforged.mod.chunk.fix; -import com.terraforged.feature.util.WorldDelegate; import com.terraforged.mod.chunk.TerraContainer; import net.minecraft.util.math.BlockPos; import net.minecraft.world.biome.Biome; @@ -36,7 +35,9 @@ import net.minecraft.world.chunk.IChunk; import net.minecraft.world.gen.ChunkGenerator; import net.minecraft.world.gen.WorldGenRegion; -public class RegionFix extends WorldDelegate { +// fixes hard-coded water and world height values +// overrides biome methods to use TerraForged's provider/manager +public class RegionFix extends RegionDelegate { private final WorldGenRegion region; private final TerraContainer container; @@ -44,7 +45,7 @@ public class RegionFix extends WorldDelegate { private final ChunkGenerator generator; public RegionFix(WorldGenRegion region, TerraContainer container, ChunkGenerator generator, BiomeManager biomeManager) { - super(region); + super(region.getWorld(), region); this.region = region; this.container = container; this.generator = generator; diff --git a/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/SaplingPlacer.java b/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/SaplingPlacer.java index 788a12c..5c335ab 100644 --- a/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/SaplingPlacer.java +++ b/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/SaplingPlacer.java @@ -60,7 +60,7 @@ public class SaplingPlacer { return false; } - TreeBuffer buffer = new TreeBuffer(event.getWorld(), event.getPos()); + TreeGrowBuffer buffer = new TreeGrowBuffer(event.getWorld(), event.getPos()); W world = feature.wrap(buffer); ChunkGenerator generator = ((ServerChunkProvider) event.getWorld().getChunkProvider()).getChunkGenerator(); @@ -85,7 +85,7 @@ public class SaplingPlacer { private static boolean placeNormal(Feature feature, SaplingGrowTreeEvent event, Vec3i[] dirs) { // apply the feature to a buffer - TreeBuffer buffer = new TreeBuffer(event.getWorld(), event.getPos()); + TreeGrowBuffer buffer = new TreeGrowBuffer(event.getWorld(), event.getPos()); buffer.placeFeature(feature, event.getPos(), event.getRand()); // check that the tree can grow here @@ -101,7 +101,7 @@ public class SaplingPlacer { return true; } - private static void applyBuffer(TreeBuffer buffer, IWorld world, BlockPos translation) { + private static void applyBuffer(TreeGrowBuffer buffer, IWorld world, BlockPos translation) { try (BlockPos.PooledMutable pos = BlockPos.PooledMutable.retain()) { for (TemplateFeature.BlockInfo block : buffer.getChanges()) { int x = block.getPos().getX() + translation.getX(); @@ -110,11 +110,9 @@ public class SaplingPlacer { pos.setPos(x, y, z); - if (pos.getY() > 90) { - BlockState current = world.getBlockState(pos); - if (current.isSolid()) { - continue; - } + BlockState current = world.getBlockState(pos); + if (current.isSolid()) { + continue; } world.setBlockState(pos, block.getState(), 2); diff --git a/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeBuffer.java b/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeGrowBuffer.java similarity index 95% rename from TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeBuffer.java rename to TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeGrowBuffer.java index 8488612..27a5371 100644 --- a/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeBuffer.java +++ b/TerraForgedMod/src/main/java/com/terraforged/mod/feature/tree/TreeGrowBuffer.java @@ -40,7 +40,7 @@ import java.util.LinkedList; import java.util.List; import java.util.Random; -public class TreeBuffer extends WorldDelegate { +public class TreeGrowBuffer extends WorldDelegate { private int topY = 0; private final BlockPos pos; @@ -48,7 +48,7 @@ public class TreeBuffer extends WorldDelegate { private final MutableVec3i baseMax = new MutableVec3i(0); private final List changes = new LinkedList<>(); - public TreeBuffer(IWorld delegate, BlockPos pos) { + public TreeGrowBuffer(IWorld delegate, BlockPos pos) { super(delegate); this.pos = pos; } @@ -71,6 +71,9 @@ public class TreeBuffer extends WorldDelegate { @Override public boolean setBlockState(BlockPos pos, BlockState state, int i) { + if (pos.getY() < this.pos.getY()) { + return false; + } if (state.isSolid()) { recordPos(pos); } diff --git a/gradle.properties b/gradle.properties index 5d1662e..4d7a7c4 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,4 +1,4 @@ -mod_version=0.0.1 +mod_version=0.0.2 mc_version=1.15.2 forge_version=31.1.1 mcp_channel=snapshot