2018-08-08 03:16:53 +00:00
|
|
|
/*
|
|
|
|
* This file is part of Baritone.
|
|
|
|
*
|
|
|
|
* Baritone is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2018-08-08 04:15:22 +00:00
|
|
|
* Baritone is distributed in the hope that it will be useful,
|
2018-08-08 03:16:53 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Baritone. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2018-08-22 20:15:56 +00:00
|
|
|
package baritone.utils;
|
2018-08-02 17:25:46 +00:00
|
|
|
|
2018-08-22 20:15:56 +00:00
|
|
|
import baritone.Baritone;
|
2018-08-23 20:39:13 +00:00
|
|
|
import baritone.chunk.WorldData;
|
2018-08-22 22:35:32 +00:00
|
|
|
import baritone.chunk.WorldProvider;
|
2018-08-02 17:25:46 +00:00
|
|
|
import net.minecraft.block.Block;
|
2018-08-06 23:06:18 +00:00
|
|
|
import net.minecraft.block.BlockFalling;
|
2018-08-06 21:32:54 +00:00
|
|
|
import net.minecraft.block.BlockLiquid;
|
2018-08-02 17:25:46 +00:00
|
|
|
import net.minecraft.block.state.IBlockState;
|
2018-08-06 21:32:54 +00:00
|
|
|
import net.minecraft.init.Blocks;
|
2018-08-02 17:25:46 +00:00
|
|
|
import net.minecraft.util.math.BlockPos;
|
2018-08-08 00:41:13 +00:00
|
|
|
import net.minecraft.world.chunk.Chunk;
|
|
|
|
|
|
|
|
public class BlockStateInterface implements Helper {
|
2018-08-02 17:25:46 +00:00
|
|
|
|
2018-08-31 18:51:43 +00:00
|
|
|
private static Chunk prev = null;
|
2018-09-01 19:26:55 +00:00
|
|
|
|
2018-08-22 19:04:44 +00:00
|
|
|
public static IBlockState get(BlockPos pos) { // wrappers for chunk caching capability
|
2018-08-08 00:41:13 +00:00
|
|
|
|
|
|
|
// Invalid vertical position
|
2018-09-08 04:32:25 +00:00
|
|
|
if (pos.getY() < 0 || pos.getY() >= 256) {
|
2018-08-08 00:41:13 +00:00
|
|
|
return Blocks.AIR.getDefaultState();
|
2018-09-08 04:32:25 +00:00
|
|
|
}
|
2018-08-08 00:41:13 +00:00
|
|
|
|
2018-08-22 19:04:44 +00:00
|
|
|
if (!Baritone.settings().pathThroughCachedOnly.get()) {
|
2018-08-31 18:51:43 +00:00
|
|
|
Chunk cached = prev;
|
|
|
|
// there's great cache locality in block state lookups
|
|
|
|
// generally it's within each movement
|
|
|
|
// if it's the same chunk as last time
|
|
|
|
// we can just skip the mc.world.getChunk lookup
|
|
|
|
// which is a Long2ObjectOpenHashMap.get
|
|
|
|
if (cached != null && cached.x == pos.getX() >> 4 && cached.z == pos.getZ() >> 4) {
|
|
|
|
return cached.getBlockState(pos);
|
|
|
|
}
|
2018-08-22 19:04:44 +00:00
|
|
|
Chunk chunk = mc.world.getChunk(pos);
|
|
|
|
if (chunk.isLoaded()) {
|
2018-08-31 18:51:43 +00:00
|
|
|
prev = chunk;
|
2018-08-22 19:04:44 +00:00
|
|
|
return chunk.getBlockState(pos);
|
|
|
|
}
|
2018-08-14 03:17:16 +00:00
|
|
|
}
|
2018-08-23 20:39:13 +00:00
|
|
|
WorldData world = WorldProvider.INSTANCE.getCurrentWorld();
|
|
|
|
if (world != null) {
|
|
|
|
IBlockState type = world.cache.getBlock(pos);
|
|
|
|
if (type != null) {
|
|
|
|
return type;
|
2018-08-08 00:41:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-23 20:39:13 +00:00
|
|
|
|
2018-08-08 00:41:13 +00:00
|
|
|
return Blocks.AIR.getDefaultState();
|
2018-08-02 17:25:46 +00:00
|
|
|
}
|
|
|
|
|
2018-09-01 19:26:55 +00:00
|
|
|
public static void clearCachedChunk() {
|
|
|
|
prev = null;
|
|
|
|
}
|
|
|
|
|
2018-08-02 17:25:46 +00:00
|
|
|
public static Block getBlock(BlockPos pos) {
|
|
|
|
return get(pos).getBlock();
|
|
|
|
}
|
2018-08-06 21:32:54 +00:00
|
|
|
|
|
|
|
public static final Block waterFlowing = Blocks.FLOWING_WATER;
|
|
|
|
public static final Block waterStill = Blocks.WATER;
|
|
|
|
public static final Block lavaFlowing = Blocks.FLOWING_LAVA;
|
|
|
|
public static final Block lavaStill = Blocks.LAVA;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns whether or not the specified block is
|
|
|
|
* water, regardless of whether or not it is flowing.
|
|
|
|
*
|
|
|
|
* @param b The block
|
|
|
|
* @return Whether or not the block is water
|
|
|
|
*/
|
|
|
|
public static boolean isWater(Block b) {
|
|
|
|
return waterFlowing.equals(b) || waterStill.equals(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns whether or not the block at the specified pos is
|
|
|
|
* water, regardless of whether or not it is flowing.
|
|
|
|
*
|
|
|
|
* @param bp The block pos
|
|
|
|
* @return Whether or not the block is water
|
|
|
|
*/
|
|
|
|
public static boolean isWater(BlockPos bp) {
|
2018-08-06 22:52:12 +00:00
|
|
|
return isWater(BlockStateInterface.getBlock(bp));
|
2018-08-06 21:32:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isLava(Block b) {
|
|
|
|
return lavaFlowing.equals(b) || lavaStill.equals(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-08-07 01:18:16 +00:00
|
|
|
* Returns whether or not the specified pos has a liquid
|
2018-08-06 21:32:54 +00:00
|
|
|
*
|
2018-08-07 01:18:16 +00:00
|
|
|
* @param p The pos
|
2018-08-06 21:32:54 +00:00
|
|
|
* @return Whether or not the block is a liquid
|
|
|
|
*/
|
|
|
|
public static boolean isLiquid(BlockPos p) {
|
2018-08-07 01:18:16 +00:00
|
|
|
return BlockStateInterface.getBlock(p) instanceof BlockLiquid;
|
2018-08-06 21:32:54 +00:00
|
|
|
}
|
|
|
|
|
2018-08-08 22:56:13 +00:00
|
|
|
public static boolean isFlowing(IBlockState state) {
|
2018-08-07 01:25:46 +00:00
|
|
|
// Will be IFluidState in 1.13
|
2018-08-06 21:32:54 +00:00
|
|
|
return state.getBlock() instanceof BlockLiquid
|
|
|
|
&& state.getPropertyKeys().contains(BlockLiquid.LEVEL)
|
|
|
|
&& state.getValue(BlockLiquid.LEVEL) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isAir(BlockPos pos) {
|
2018-08-06 22:52:12 +00:00
|
|
|
return BlockStateInterface.getBlock(pos).equals(Blocks.AIR);
|
2018-08-06 21:32:54 +00:00
|
|
|
}
|
|
|
|
|
2018-08-07 14:39:55 +00:00
|
|
|
public static boolean isAir(IBlockState state) {
|
|
|
|
return state.getBlock().equals(Blocks.AIR);
|
|
|
|
}
|
|
|
|
|
2018-08-06 23:06:18 +00:00
|
|
|
static boolean canFall(BlockPos pos) {
|
|
|
|
return BlockStateInterface.get(pos).getBlock() instanceof BlockFalling;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-08-02 17:25:46 +00:00
|
|
|
}
|