Fix alveary climate change calculations (#109)

Co-authored-by: Martin Robertz <[email protected]>
Co-authored-by: UltraProdigy <[email protected]>

.github/workflows/optimize-images.yml

@@ -0,0 +1,17 @@
+name: Optimize images
+
+on:
+  pull_request:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+  push:
+    branches: [ master, main, release/** ]
+    paths:
+      - "**/*.png"
+
+jobs:
+  optimize-images:
+    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/optimize-images.yml@master
+    secrets: inherit

dependencies.gradle

@@ -1,6 +1,7 @@
 // Add your dependencies here
 
 dependencies {
+    api("com.github.GTNewHorizons:GTNHLib:0.9.41:dev")
     api('curse.maven:cofh-lib-220333:2388748')
     compileOnlyApi('com.github.GTNewHorizons:Angelica:1.0.0-beta68a:api')
     devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.8.70-GTNH:dev')

src/main/java/forestry/Forestry.java

@@ -57,7 +57,8 @@ import forestry.plugins.PluginManager;
         name = Constants.MOD,
         version = Constants.VERSION,
         guiFactory = "forestry.core.config.ForestryGuiConfigFactory",
-        dependencies = "required-after:Forge@[10.13.4.1566,);" + "after:Buildcraft|Core@[6.1.7,);"
+        dependencies = "required-after:Forge@[10.13.4.1566,);" + "required-after:gtnhlib@[0.9.41,);"
+                + "after:Buildcraft|Core@[6.1.7,);"
                 + "after:ExtrabiomesXL;"
                 + "after:BiomesOPlenty;"
                 + "after:IC2@[2.0.140,);"

src/main/java/forestry/apiculture/multiblock/AlvearyController.java

@@ -250,8 +250,9 @@ public class AlvearyController extends RectangularMultiblockControllerBase
 
     private float applyChange(float base, float currentChange, float extraChange, float boundaryDown,
             float boundaryUp) {
-        float boundedNewChange = Math.max(boundaryDown, Math.min(base + currentChange + (extraChange * 20), boundaryUp))
-                - base;
+        float boundedNewChange = Math.round(
+                (Math.max(boundaryDown, Math.min(base + currentChange + (extraChange * 20), boundaryUp)) - base) * 100)
+                / 100.0f;
         if (extraChange > 0) {
             return Math.max(currentChange, boundedNewChange);
         } else {
@@ -355,12 +356,13 @@ public class AlvearyController extends RectangularMultiblockControllerBase
     @Override
     public float getExactTemperature() {
         ChunkCoordinates coords = getReferenceCoord();
-        return getBiome().getFloatTemperature(coords.posX, coords.posY, coords.posZ) + tempChange;
+        return Math.round((getBiome().getFloatTemperature(coords.posX, coords.posY, coords.posZ) + tempChange) * 100)
+                / 100.0f;
     }
 
     @Override
     public float getExactHumidity() {
-        return getBiome().rainfall + humidChange;
+        return Math.round((getBiome().rainfall + humidChange) * 100) / 100.0f;
     }
 
     @Override

src/main/java/forestry/arboriculture/LeafDecayHelper.java

@@ -1,145 +0,0 @@
-package forestry.arboriculture;
-
-import net.minecraft.block.Block;
-import net.minecraft.block.BlockLeaves;
-import net.minecraft.world.World;
-
-/** Based on vanilla leaf decay, but accepts leaves that are connected further from a trunk */
-public abstract class LeafDecayHelper {
-
-    private static final short SUSTAINS_LEAVES = 0;
-    private static final short NOT_SUSTAINS_LEAVES = -1;
-    private static final short IS_LEAVES = -2;
-    private static int[] leafDecayValues;
-
-    public static void leafDecay(BlockLeaves leaves, World world, int x, int y, int z) {
-        if (world.isRemote) {
-            return;
-        }
-
-        int leafMeta = world.getBlockMetadata(x, y, z);
-
-        if ((leafMeta & 8) != 0 && (leafMeta & 4) == 0) {
-            byte radius = 4;
-            byte yArrayMult = 32;
-            int xArrayMult = yArrayMult * yArrayMult;
-            int arrayOffset = yArrayMult / 2;
-
-            if (leafDecayValues == null) {
-                leafDecayValues = new int[yArrayMult * yArrayMult * yArrayMult];
-            }
-
-            int radius1 = radius + 1;
-            if (world.checkChunksExist(x - radius1, y - radius1, z - radius1, x + radius1, y + radius1, z + radius1)) {
-                for (int xOffset = -radius; xOffset <= radius; ++xOffset) {
-                    for (int yOffset = -radius; yOffset <= radius; ++yOffset) {
-                        for (int zOffset = -radius; zOffset <= radius; ++zOffset) {
-                            Block block = world.getBlock(x + xOffset, y + yOffset, z + zOffset);
-
-                            if (!block.canSustainLeaves(world, x + xOffset, y + yOffset, z + zOffset)) {
-                                if (block.isLeaves(world, x + xOffset, y + yOffset, z + zOffset)) {
-                                    leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] = IS_LEAVES;
-                                } else {
-                                    leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] = NOT_SUSTAINS_LEAVES;
-                                }
-                            } else {
-                                leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                        + (yOffset + arrayOffset) * yArrayMult
-                                        + zOffset
-                                        + arrayOffset] = SUSTAINS_LEAVES;
-                            }
-                        }
-                    }
-                }
-
-                for (int sustainedValue = 1; sustainedValue <= 8; ++sustainedValue) {
-                    for (int xOffset = -radius; xOffset <= radius; ++xOffset) {
-                        for (int yOffset = -radius; yOffset <= radius; ++yOffset) {
-                            for (int zOffset = -radius; zOffset <= radius; ++zOffset) {
-                                if (leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                        + (yOffset + arrayOffset) * yArrayMult
-                                        + zOffset
-                                        + arrayOffset] == sustainedValue - 1) {
-                                    if (leafDecayValues[(xOffset + arrayOffset - 1) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset - 1) * xArrayMult
-                                                + (yOffset + arrayOffset) * yArrayMult
-                                                + zOffset
-                                                + arrayOffset] = sustainedValue;
-                                    }
-
-                                    if (leafDecayValues[(xOffset + arrayOffset + 1) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset + 1) * xArrayMult
-                                                + (yOffset + arrayOffset) * yArrayMult
-                                                + zOffset
-                                                + arrayOffset] = sustainedValue;
-                                    }
-
-                                    if (leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset - 1) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                                + (yOffset + arrayOffset - 1) * yArrayMult
-                                                + zOffset
-                                                + arrayOffset] = sustainedValue;
-                                    }
-
-                                    if (leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset + 1) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                                + (yOffset + arrayOffset + 1) * yArrayMult
-                                                + zOffset
-                                                + arrayOffset] = sustainedValue;
-                                    }
-
-                                    if (leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + (zOffset + arrayOffset - 1)] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                                + (yOffset + arrayOffset) * yArrayMult
-                                                + (zOffset + arrayOffset - 1)] = sustainedValue;
-                                    }
-
-                                    if (leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                            + (yOffset + arrayOffset) * yArrayMult
-                                            + zOffset
-                                            + arrayOffset
-                                            + 1] == IS_LEAVES) {
-                                        leafDecayValues[(xOffset + arrayOffset) * xArrayMult
-                                                + (yOffset + arrayOffset) * yArrayMult
-                                                + zOffset
-                                                + arrayOffset
-                                                + 1] = sustainedValue;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            int sustainValue = leafDecayValues[(arrayOffset * xArrayMult) + (arrayOffset * yArrayMult) + arrayOffset];
-
-            if (sustainValue >= 0) {
-                world.setBlockMetadataWithNotify(x, y, z, leafMeta & -9, 4); // stop trying to decay
-            } else {
-                leaves.dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
-                world.setBlockToAir(x, y, z);
-            }
-        }
-    }
-}

src/main/java/forestry/arboriculture/blocks/BlockForestryLeaves.java

@@ -34,6 +34,7 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.ForgeDirection;
 
+import com.gtnewhorizon.gtnhlib.blocks.util.BFSLeafDecay;
 import com.mojang.authlib.GameProfile;
 
 import cpw.mods.fml.relauncher.Side;
@@ -48,7 +49,6 @@ import forestry.api.core.Tabs;
 import forestry.api.lepidopterology.ButterflyManager;
 import forestry.api.lepidopterology.EnumFlutterType;
 import forestry.api.lepidopterology.IButterfly;
-import forestry.arboriculture.LeafDecayHelper;
 import forestry.arboriculture.genetics.TreeDefinition;
 import forestry.arboriculture.items.ItemBlockLeaves;
 import forestry.arboriculture.render.TextureLeaves;
@@ -230,7 +230,12 @@ public class BlockForestryLeaves extends BlockNewLeaf implements ITileEntityProv
             return;
         }
 
-        LeafDecayHelper.leafDecay(this, world, x, y, z);
+        if (!world.isRemote) {
+            final int meta = world.getBlockMetadata(x, y, z);
+            if ((meta & 8) != 0 && (meta & 4) == 0) {
+                BFSLeafDecay.handleDecayChecked(this, world, x, y, z, meta, 4);
+            }
+        }
 
         // check leaves tile again because they can decay in super.updateTick
         if (tileLeaves.isInvalid()) {

src/main/java/forestry/arboriculture/blocks/BlockFruitPod.java

@@ -36,29 +36,29 @@ public class BlockFruitPod extends BlockCocoa {
     }
 
     public static TileFruitPod getPodTile(IBlockAccess world, int x, int y, int z) {
-        TileEntity tile = world.getTileEntity(x, y, z);
-        if (!(tile instanceof TileFruitPod)) {
-            return null;
+        final TileEntity tile = world.getTileEntity(x, y, z);
+        if (tile instanceof TileFruitPod) {
+            return (TileFruitPod) tile;
         }
-
-        return (TileFruitPod) tile;
+        return null;
     }
 
     @Override
     public void updateTick(World world, int x, int y, int z, Random rand) {
-
+        if (!world.checkChunksExist(x - 1, y, z - 1, x + 1, y, z + 1)) {
+            return;
+        }
         if (!canBlockStay(world, x, y, z)) {
-            dropBlockAsItem(world, x, y, z, world.getBlockMetadata(x, y, z), 0);
+            final int meta = world.getBlockMetadata(x, y, z);
+            this.dropBlockAsItem(world, x, y, z, meta, 0);
             world.setBlockToAir(x, y, z);
             return;
         }
 
-        TileFruitPod tile = getPodTile(world, x, y, z);
-        if (tile == null) {
-            return;
+        final TileFruitPod tile = getPodTile(world, x, y, z);
+        if (tile != null) {
+            tile.onBlockTick();
         }
-
-        tile.onBlockTick();
     }
 
     @SuppressWarnings("deprecation")

src/main/java/forestry/core/blocks/BlockSoil.java

@@ -84,31 +84,26 @@ public class BlockSoil extends Block implements IItemTyped {
     }
 
     @Override
-    public void updateTick(World world, int i, int j, int k, Random random) {
+    public void updateTick(World world, int x, int y, int z, Random random) {
         if (world.isRemote) {
             return;
         }
 
-        int meta = world.getBlockMetadata(i, j, k);
-
+        int meta = world.getBlockMetadata(x, y, z);
         SoilType type = getTypeFromMeta(meta);
 
         if (type == SoilType.HUMUS) {
-            updateTickHumus(world, i, j, k);
+            if (world.checkChunksExist(x - 1, y + 1, z - 1, x + 1, y + 1, z + 1)) {
+                if (isEnrooted(world, x, y, z)) {
+                    degradeSoil(world, x, y, z);
+                }
+            }
         } else if (type == SoilType.BOG_EARTH) {
-            updateTickBogEarth(world, i, j, k);
-        }
-    }
-
-    private static void updateTickHumus(World world, int i, int j, int k) {
-        if (isEnrooted(world, i, j, k)) {
-            degradeSoil(world, i, j, k);
-        }
-    }
-
-    private static void updateTickBogEarth(World world, int i, int j, int k) {
-        if (isMoistened(world, i, j, k)) {
-            matureBog(world, i, j, k);
+            if (world.checkChunksExist(x - 2, y, z - 2, x + 2, y, z + 2)) {
+                if (isMoistened(world, x, y, z)) {
+                    matureBog(world, x, y, z);
+                }
+            }
         }
     }
 
@@ -122,7 +117,6 @@ public class BlockSoil extends Block implements IItemTyped {
                 }
             }
         }
-
         return false;
     }
 
@@ -156,7 +150,6 @@ public class BlockSoil extends Block implements IItemTyped {
     }
 
     private static boolean isMoistened(World world, int x, int y, int z) {
-
         for (int i = -2; i < 3; i++) {
             for (int j = -2; j < 3; j++) {
                 Block block = world.getBlock(x + i, y, z + j);
@@ -165,7 +158,6 @@ public class BlockSoil extends Block implements IItemTyped {
                 }
             }
         }
-
         return false;
     }
 

src/main/java/forestry/core/fluids/BlockForestryFluid.java

@@ -193,7 +193,7 @@ public class BlockForestryFluid extends BlockFluidClassic {
         super.updateTick(world, x, y, z, rand);
 
         // Start fires if the fluid is lava-like
-        if (getMaterial() == Material.lava) {
+        if (getMaterial() == Material.lava && world.checkChunksExist(x - 4, y, z - 4, x + 4, y, z + 4)) {
             int rangeUp = rand.nextInt(3);
 
             for (int i = 0; i < rangeUp; ++i) {

src/main/java/forestry/farming/blocks/BlockMushroom.java

@@ -72,51 +72,54 @@ public class BlockMushroom extends BlockSapling implements IItemTyped {
     }
 
     @Override
-    public void updateTick(World world, int i, int j, int k, Random random) {
-
+    public void updateTick(World world, int x, int y, int z, Random random) {
         if (world.isRemote) {
             return;
         }
 
-        int meta = world.getBlockMetadata(i, j, k);
-        MushroomType type = getTypeFromMeta(meta);
-        int maturity = meta >> 2;
+        final int meta = world.getBlockMetadata(x, y, z);
+        final MushroomType type = getTypeFromMeta(meta);
+        final int maturity = meta >> 2;
 
-        tickGermling(world, i, j, k, random, type, maturity);
+        tickGermling(world, x, y, z, random, type, maturity);
     }
 
-    private void tickGermling(World world, int i, int j, int k, Random random, MushroomType type, int maturity) {
-
-        int lightvalue = world.getBlockLightValue(i, j + 1, k);
-
+    private void tickGermling(World world, int x, int y, int z, Random random, MushroomType type, int maturity) {
         if (random.nextInt(2) != 0) {
             return;
         }
-
         if (maturity != 3) {
             maturity = 3;
-            int matX = maturity << 2;
-            int meta = (matX | type.ordinal());
-            world.setBlockMetadataWithNotify(i, j, k, meta, Constants.FLAG_BLOCK_SYNCH);
-        } else if (lightvalue <= 7) {
-            func_149878_d(world, i, j, k, random);
+            final int matX = maturity << 2;
+            final int meta = (matX | type.ordinal());
+            world.setBlockMetadataWithNotify(x, y, z, meta, Constants.FLAG_BLOCK_SYNCH);
+        } else {
+            if (world.checkChunksExist(x - 1, y, z - 1, x + 1, y, z + 1)) {
+                final int lightvalue = world.getBlockLightValue(x, y + 1, z);
+                if (lightvalue <= 7) {
+                    func_149878_d(world, x, y, z, random);
+                }
+            }
         }
     }
 
     @Override
-    public void func_149878_d(World world, int i, int j, int k, Random random) {
-        MushroomType type = getTypeFromMeta(world.getBlockMetadata(i, j, k));
+    public void func_149878_d(World world, int x, int y, int z, Random random) {
+        MushroomType type = getTypeFromMeta(world.getBlockMetadata(x, y, z));
 
-        world.setBlockToAir(i, j, k);
-        if (!generators[type.ordinal()].generate(world, random, i, j, k)) {
-            world.setBlock(i, j, k, this, type.ordinal(), 0);
+        world.setBlockToAir(x, y, z);
+        if (!generators[type.ordinal()].generate(world, random, x, y, z)) {
+            world.setBlock(x, y, z, this, type.ordinal(), 0);
         }
     }
 
     @Override
     public MushroomType getTypeFromMeta(int meta) {
-        meta %= MushroomType.values().length;
-        return MushroomType.values()[meta];
+        return switch (meta % 2) {
+            case 0 -> MushroomType.BROWN;
+            case 1 -> MushroomType.RED;
+            default -> throw new IllegalStateException("Unexpected value: " + meta);
+        };
     }
 
     /* ICONS */
@@ -135,15 +138,10 @@ public class BlockMushroom extends BlockSapling implements IItemTyped {
     @SideOnly(Side.CLIENT)
     @Override
     public IIcon getIcon(int side, int meta) {
-        MushroomType type = getTypeFromMeta(meta);
-
-        switch (type) {
-            case BROWN:
-                return Blocks.brown_mushroom.getIcon(side, meta);
-            case RED:
-                return Blocks.red_mushroom.getIcon(side, meta);
-            default:
-                return null;
-        }
+        final MushroomType type = getTypeFromMeta(meta);
+        return switch (type) {
+            case BROWN -> Blocks.brown_mushroom.getIcon(side, meta);
+            case RED -> Blocks.red_mushroom.getIcon(side, meta);
+        };
     }
 }