ActuallyAdditions/src/main/java/de/ellpeck/actuallyadditions/mod/items/ItemDrill.java

512 lines
20 KiB
Java
Raw Normal View History

2015-08-29 14:33:25 +02:00
/*
2016-05-16 22:52:27 +02:00
* This file ("ItemDrill.java") is part of the Actually Additions mod for Minecraft.
2015-08-29 14:33:25 +02:00
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
2016-05-16 22:52:27 +02:00
* http://ellpeck.de/actaddlicense
2015-08-29 14:33:25 +02:00
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2017-01-01 16:23:26 +01:00
* © 2015-2017 Ellpeck
2015-08-29 14:33:25 +02:00
*/
2016-01-05 04:47:35 +01:00
package de.ellpeck.actuallyadditions.mod.items;
2015-06-15 22:06:07 +02:00
import com.google.common.collect.Multimap;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
import de.ellpeck.actuallyadditions.mod.blocks.metalists.TheColoredLampColors;
import de.ellpeck.actuallyadditions.mod.config.values.ConfigStringListValues;
import de.ellpeck.actuallyadditions.mod.inventory.ContainerDrill;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.inventory.GuiHandler;
import de.ellpeck.actuallyadditions.mod.items.base.ItemEnergy;
import de.ellpeck.actuallyadditions.mod.tile.TileEntityInventoryBase;
import de.ellpeck.actuallyadditions.mod.util.ItemStackHandlerAA;
import de.ellpeck.actuallyadditions.mod.util.ItemUtil;
import de.ellpeck.actuallyadditions.mod.util.StackUtil;
import de.ellpeck.actuallyadditions.mod.util.WorldUtil;
2015-06-15 22:06:07 +02:00
import net.minecraft.block.Block;
2021-02-27 16:33:00 +01:00
import net.minecraft.block.BlockState;
import net.minecraft.block.Blocks;
2015-06-15 22:06:07 +02:00
import net.minecraft.block.material.Material;
2021-02-27 16:33:00 +01:00
import net.minecraft.enchantment.Enchantments;
2015-06-15 22:06:07 +02:00
import net.minecraft.entity.ai.attributes.AttributeModifier;
2021-02-26 22:15:48 +01:00
import net.minecraft.entity.player.PlayerEntity;
2015-06-15 22:06:07 +02:00
import net.minecraft.item.ItemStack;
2021-02-26 22:15:48 +01:00
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.util.ActionResult;
2021-02-26 22:15:48 +01:00
import net.minecraft.util.Hand;
import net.minecraft.util.NonNullList;
import net.minecraft.util.ResourceLocation;
2016-03-18 23:47:22 +01:00
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.RayTraceResult;
2015-06-15 22:06:07 +02:00
import net.minecraft.world.World;
2021-02-27 16:33:00 +01:00
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
2018-01-31 06:07:29 +01:00
import net.minecraftforge.common.ForgeHooks;
import net.minecraftforge.items.IItemHandler;
import net.minecraftforge.items.IItemHandlerModifiable;
2015-06-15 22:06:07 +02:00
2021-02-26 22:15:48 +01:00
import java.util.HashSet;
import java.util.List;
import java.util.Set;
2019-05-02 09:10:29 +02:00
public class ItemDrill extends ItemEnergy {
2015-06-15 22:06:07 +02:00
public static final int HARVEST_LEVEL = 4;
2016-07-07 17:59:45 +02:00
private static final int ENERGY_USE = 100;
public ItemDrill() {
2016-11-21 13:38:43 +01:00
super(250000, 1000, name);
this.setMaxDamage(0);
2015-12-01 18:27:40 +01:00
this.setHasSubtypes(true);
this.setHarvestLevel("shovel", HARVEST_LEVEL);
this.setHarvestLevel("pickaxe", HARVEST_LEVEL);
}
2016-06-17 23:50:38 +02:00
/**
* Gets all of the Slots from NBT
*
* @param stack The Drill
*/
2019-05-02 09:10:29 +02:00
public static void loadSlotsFromNBT(IItemHandlerModifiable slots, ItemStack stack) {
2021-02-26 22:15:48 +01:00
CompoundNBT compound = stack.getTagCompound();
2019-05-02 09:10:29 +02:00
if (compound != null) {
2016-06-17 23:50:38 +02:00
TileEntityInventoryBase.loadSlots(slots, compound);
}
}
/**
* Writes all of the Slots to NBT
*
* @param slots The Slots
* @param stack The Drill
*/
2019-05-02 09:10:29 +02:00
public static void writeSlotsToNBT(IItemHandler slots, ItemStack stack) {
2021-02-26 22:15:48 +01:00
CompoundNBT compound = stack.getTagCompound();
2019-05-02 09:10:29 +02:00
if (compound == null) {
2021-02-26 22:15:48 +01:00
compound = new CompoundNBT();
2016-06-17 23:50:38 +02:00
}
TileEntityInventoryBase.saveSlots(slots, compound);
stack.setTagCompound(compound);
}
2015-06-21 02:28:49 +02:00
@Override
//Places Blocks if the Placing Upgrade is installed
2021-02-26 22:15:48 +01:00
public EnumActionResult onItemUse(PlayerEntity player, World world, BlockPos pos, Hand hand, EnumFacing side, float hitX, float hitY, float hitZ) {
2016-11-19 21:11:17 +01:00
ItemStack stack = player.getHeldItem(hand);
2015-06-21 02:28:49 +02:00
ItemStack upgrade = this.getHasUpgradeAsStack(stack, ItemDrillUpgrade.UpgradeType.PLACER);
2019-05-02 09:10:29 +02:00
if (StackUtil.isValid(upgrade)) {
2015-06-21 02:28:49 +02:00
int slot = ItemDrillUpgrade.getSlotToPlaceFrom(upgrade);
2021-02-27 21:24:26 +01:00
if (slot >= 0 && slot < PlayerInventory.getHotbarSize()) {
ItemStack equip = player.inventory.getStackInSlot(slot);
2019-05-02 09:10:29 +02:00
if (StackUtil.isValid(equip) && equip != stack) {
ItemStack toPlaceStack = equip.copy();
WorldUtil.setHandItemWithoutAnnoyingSound(player, hand, toPlaceStack);
//tryPlaceItemIntoWorld could throw an Exception
2019-05-02 09:10:29 +02:00
try {
//Places the Block into the World
2019-05-02 09:10:29 +02:00
if (toPlaceStack.onItemUse(player, world, pos, hand, side, hitX, hitY, hitZ) != EnumActionResult.FAIL) {
2021-02-28 15:47:54 +01:00
if (!player.isCreative()) {
WorldUtil.setHandItemWithoutAnnoyingSound(player, hand, toPlaceStack.copy());
2015-06-22 18:09:00 +02:00
}
2015-06-21 02:28:49 +02:00
}
}
//Notify the Player and log the Exception
2019-05-02 09:10:29 +02:00
catch (Exception e) {
ActuallyAdditions.LOGGER.error("Player " + player.getName() + " who should place a Block using a Drill at " + player.posX + ", " + player.posY + ", " + player.posZ + " in World " + world.provider.getDimension() + " threw an Exception! Don't let that happen again!");
2015-10-02 16:48:01 +02:00
}
player.inventory.setInventorySlotContents(slot, player.getHeldItem(hand));
WorldUtil.setHandItemWithoutAnnoyingSound(player, hand, stack);
return EnumActionResult.SUCCESS;
2015-06-21 02:28:49 +02:00
}
}
}
2016-03-18 23:47:22 +01:00
return EnumActionResult.FAIL;
2015-06-21 02:28:49 +02:00
}
2015-10-03 10:19:40 +02:00
/**
* Checks if a certain Upgrade is installed and returns it as an ItemStack
*
* @param stack The Drill
* @param upgrade The Upgrade to be checked
2021-02-26 22:15:48 +01:00
*
2015-10-03 10:19:40 +02:00
* @return The Upgrade, if it's installed
*/
2019-05-02 09:10:29 +02:00
public ItemStack getHasUpgradeAsStack(ItemStack stack, ItemDrillUpgrade.UpgradeType upgrade) {
2021-02-26 22:15:48 +01:00
CompoundNBT compound = stack.getTagCompound();
if (compound == null) {
return StackUtil.getEmpty();
}
2015-10-03 10:19:40 +02:00
ItemStackHandlerAA inv = new ItemStackHandlerAA(ContainerDrill.SLOT_AMOUNT);
loadSlotsFromNBT(inv, stack);
2019-05-02 09:10:29 +02:00
for (int i = 0; i < inv.getSlots(); i++) {
ItemStack slotStack = inv.getStackInSlot(i);
2019-05-02 09:10:29 +02:00
if (StackUtil.isValid(slotStack) && slotStack.getItem() instanceof ItemDrillUpgrade) {
2021-02-26 22:15:48 +01:00
if (((ItemDrillUpgrade) slotStack.getItem()).type == upgrade) {
return slotStack;
}
2015-10-03 10:19:40 +02:00
}
}
2017-11-02 22:49:53 +01:00
return StackUtil.getEmpty();
2015-10-03 10:19:40 +02:00
}
@Override
2021-02-26 22:15:48 +01:00
public ActionResult<ItemStack> onItemRightClick(World world, PlayerEntity player, Hand hand) {
if (!world.isRemote && player.isSneaking() && hand == Hand.MAIN_HAND) {
2019-05-02 09:10:29 +02:00
player.openGui(ActuallyAdditions.INSTANCE, GuiHandler.GuiTypes.DRILL.ordinal(), world, (int) player.posX, (int) player.posY, (int) player.posZ);
2015-10-03 10:19:40 +02:00
}
2019-02-27 19:53:05 +01:00
return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
2015-10-03 10:19:40 +02:00
}
2015-12-01 19:48:09 +01:00
@Override
2019-05-02 09:10:29 +02:00
public int getMetadata(int damage) {
2015-12-01 19:48:09 +01:00
return damage;
}
2015-10-03 10:19:40 +02:00
@Override
2019-05-02 09:10:29 +02:00
public boolean hitEntity(ItemStack stack, EntityLivingBase entity1, EntityLivingBase entity2) {
2015-10-03 10:19:40 +02:00
int use = this.getEnergyUsePerBlock(stack);
2021-02-28 15:47:54 +01:00
if (!(entity2 instanceof PlayerEntity) || !((PlayerEntity) entity2).isCreative()) {
2019-05-02 09:10:29 +02:00
if (this.getEnergyStored(stack) >= use) {
this.extractEnergyInternal(stack, use, false);
}
2015-10-03 10:19:40 +02:00
}
return true;
}
@Override
2019-05-02 09:10:29 +02:00
public EnumRarity getRarity(ItemStack stack) {
return EnumRarity.EPIC;
2015-10-03 10:19:40 +02:00
}
2016-05-02 17:09:23 +02:00
@Override
2019-05-02 09:10:29 +02:00
public Multimap<String, AttributeModifier> getAttributeModifiers(EntityEquipmentSlot slot, ItemStack stack) {
2016-03-19 11:42:11 +01:00
Multimap<String, AttributeModifier> map = super.getAttributeModifiers(slot, stack);
2019-05-02 09:10:29 +02:00
if (slot == EntityEquipmentSlot.MAINHAND) {
2021-02-26 22:15:48 +01:00
map.put(SharedMonsterAttributes.ATTACK_DAMAGE.getName(), new AttributeModifier(ATTACK_DAMAGE_MODIFIER, "Drill Modifier", this.getEnergyStored(stack) >= ENERGY_USE
? 8.0F
: 0.1F, 0));
2016-11-26 21:32:27 +01:00
map.put(SharedMonsterAttributes.ATTACK_SPEED.getName(), new AttributeModifier(ATTACK_SPEED_MODIFIER, "Tool Modifier", -2.5F, 0));
2016-03-19 11:42:11 +01:00
}
2015-10-03 10:19:40 +02:00
return map;
}
@Override
2021-02-26 22:15:48 +01:00
public float getDestroySpeed(ItemStack stack, BlockState state) {
return this.getEnergyStored(stack) >= this.getEnergyUsePerBlock(stack)
? this.hasExtraWhitelist(state.getBlock()) || state.getBlock().getHarvestTool(state) == null || state.getBlock().getHarvestTool(state).isEmpty() || this.getToolClasses(stack).contains(state.getBlock().getHarvestTool(state))
? this.getEfficiencyFromUpgrade(stack)
: 1.0F
: 0.1F;
2015-10-03 10:19:40 +02:00
}
@Override
2021-02-26 22:15:48 +01:00
public boolean onBlockStartBreak(ItemStack stack, BlockPos pos, PlayerEntity player) {
boolean toReturn = false;
2015-10-03 10:19:40 +02:00
int use = this.getEnergyUsePerBlock(stack);
2019-05-02 09:10:29 +02:00
if (this.getEnergyStored(stack) >= use) {
2015-10-03 10:19:40 +02:00
//Enchants the Drill depending on the Upgrades it has
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SILK_TOUCH)) {
2016-04-20 21:39:03 +02:00
ItemUtil.addEnchantment(stack, Enchantments.SILK_TOUCH, 1);
2019-05-02 09:10:29 +02:00
} else {
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FORTUNE)) {
2021-02-26 22:15:48 +01:00
ItemUtil.addEnchantment(stack, Enchantments.FORTUNE, this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FORTUNE_II)
? 3
: 1);
2015-10-03 10:19:40 +02:00
}
}
//Block hit
2016-11-26 21:32:27 +01:00
RayTraceResult ray = WorldUtil.getNearestBlockWithDefaultReachDistance(player.world, player);
2019-05-02 09:10:29 +02:00
if (ray != null) {
2019-02-27 19:53:05 +01:00
//Breaks the Blocks
2019-05-02 09:10:29 +02:00
if (!player.isSneaking() && this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.THREE_BY_THREE)) {
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FIVE_BY_FIVE)) {
toReturn = this.breakBlocks(stack, 2, player.world, pos, ray.sideHit, player);
2019-05-02 09:10:29 +02:00
} else {
toReturn = this.breakBlocks(stack, 1, player.world, pos, ray.sideHit, player);
}
2019-05-02 09:10:29 +02:00
} else {
toReturn = this.breakBlocks(stack, 0, player.world, pos, ray.sideHit, player);
2015-10-02 16:48:01 +02:00
}
2015-10-03 10:19:40 +02:00
//Removes Enchantments added above
ItemUtil.removeEnchantment(stack, Enchantments.SILK_TOUCH);
ItemUtil.removeEnchantment(stack, Enchantments.FORTUNE);
}
2015-06-15 22:06:07 +02:00
}
2015-10-03 10:19:40 +02:00
return toReturn;
}
@Override
2021-02-26 22:15:48 +01:00
public boolean canHarvestBlock(BlockState state, ItemStack stack) {
2016-03-18 23:47:22 +01:00
Block block = state.getBlock();
2021-02-26 22:15:48 +01:00
return this.getEnergyStored(stack) >= this.getEnergyUsePerBlock(stack) && (this.hasExtraWhitelist(block) || state.getMaterial().isToolNotRequired() || block == Blocks.SNOW_LAYER || block == Blocks.SNOW || (block == Blocks.OBSIDIAN
? HARVEST_LEVEL >= 3
: block != Blocks.DIAMOND_BLOCK && block != Blocks.DIAMOND_ORE
? block != Blocks.EMERALD_ORE && block != Blocks.EMERALD_BLOCK
? block != Blocks.GOLD_BLOCK && block != Blocks.GOLD_ORE
? block != Blocks.IRON_BLOCK && block != Blocks.IRON_ORE
? block != Blocks.LAPIS_BLOCK && block != Blocks.LAPIS_ORE
? block != Blocks.REDSTONE_ORE && block != Blocks.LIT_REDSTONE_ORE
? state.getMaterial() == Material.ROCK || state.getMaterial() == Material.IRON || state.getMaterial() == Material.ANVIL
: HARVEST_LEVEL >= 2
: HARVEST_LEVEL >= 1
: HARVEST_LEVEL >= 1
: HARVEST_LEVEL >= 2
: HARVEST_LEVEL >= 2
: HARVEST_LEVEL >= 2));
2015-10-03 10:19:40 +02:00
}
@Override
2019-05-02 09:10:29 +02:00
public Set<String> getToolClasses(ItemStack stack) {
2019-02-27 19:53:05 +01:00
HashSet<String> hashSet = new HashSet<>();
2015-10-03 10:19:40 +02:00
hashSet.add("pickaxe");
hashSet.add("shovel");
return hashSet;
}
@Override
2021-02-26 22:15:48 +01:00
public int getHarvestLevel(ItemStack stack, String toolClass, PlayerEntity player, BlockState blockState) {
return HARVEST_LEVEL;
2015-06-18 13:14:57 +02:00
}
2015-06-15 22:06:07 +02:00
/**
* Gets the Energy that is used per Block broken
2015-10-02 16:48:01 +02:00
*
* @param stack The Drill
2021-02-26 22:15:48 +01:00
*
* @return The Energy use per Block
*/
2019-05-02 09:10:29 +02:00
public int getEnergyUsePerBlock(ItemStack stack) {
int use = ENERGY_USE;
2015-06-21 02:28:49 +02:00
//Speed
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED)) {
use += 50;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED_II)) {
use += 75;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED_III)) {
use += 175;
2015-10-02 16:48:01 +02:00
}
2015-06-15 22:06:07 +02:00
}
}
//Silk Touch
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SILK_TOUCH)) {
use += 100;
2015-10-02 16:48:01 +02:00
}
2015-06-21 02:28:49 +02:00
//Fortune
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FORTUNE)) {
use += 40;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FORTUNE_II)) {
use += 80;
2015-10-02 16:48:01 +02:00
}
2015-06-15 22:06:07 +02:00
}
//Size
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.THREE_BY_THREE)) {
use += 10;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FIVE_BY_FIVE)) {
use += 30;
2015-10-02 16:48:01 +02:00
}
2015-06-15 22:06:07 +02:00
}
2015-06-21 02:28:49 +02:00
return use;
2015-06-15 22:06:07 +02:00
}
/**
* Checks if a certain Upgrade is applied
2015-10-02 16:48:01 +02:00
*
* @param stack The Drill
* @param upgrade The Upgrade to be checked
2021-02-26 22:15:48 +01:00
*
* @return Is the Upgrade applied?
*/
2019-05-02 09:10:29 +02:00
public boolean getHasUpgrade(ItemStack stack, ItemDrillUpgrade.UpgradeType upgrade) {
return StackUtil.isValid(this.getHasUpgradeAsStack(stack, upgrade));
2015-06-21 02:28:49 +02:00
}
2015-06-15 22:06:07 +02:00
2016-02-01 17:49:55 +01:00
@Override
2019-05-02 09:10:29 +02:00
protected void registerRendering() {
for (int i = 0; i < 16; i++) {
String name = this.getRegistryName() + "_" + TheColoredLampColors.values()[i].regName;
2018-05-10 11:38:58 +02:00
ActuallyAdditions.PROXY.addRenderRegister(new ItemStack(this, 1, i), new ResourceLocation(name), "inventory");
2016-02-01 17:49:55 +01:00
}
}
2015-12-01 19:48:09 +01:00
@Override
2021-02-26 22:15:48 +01:00
@OnlyIn(Dist.CLIENT)
2019-05-02 09:10:29 +02:00
public void getSubItems(CreativeTabs tabs, NonNullList<ItemStack> list) {
if (this.isInCreativeTab(tabs)) {
for (int i = 0; i < 16; i++) {
2017-06-17 00:48:49 +02:00
this.addDrillStack(list, i);
}
2015-12-01 19:48:09 +01:00
}
}
2019-05-02 09:10:29 +02:00
private void addDrillStack(List<ItemStack> list, int meta) {
2015-12-01 19:48:09 +01:00
ItemStack stackFull = new ItemStack(this, 1, meta);
this.setEnergy(stackFull, this.getMaxEnergyStored(stackFull));
list.add(stackFull);
ItemStack stackEmpty = new ItemStack(this, 1, meta);
this.setEnergy(stackEmpty, 0);
list.add(stackEmpty);
}
/**
2015-10-03 10:19:40 +02:00
* Gets the Mining Speed of the Drill
2015-10-02 16:48:01 +02:00
*
2015-10-03 10:19:40 +02:00
* @param stack The Drill
2021-02-26 22:15:48 +01:00
*
2015-10-03 10:19:40 +02:00
* @return The Mining Speed depending on the Speed Upgrades
*/
2019-05-02 09:10:29 +02:00
public float getEfficiencyFromUpgrade(ItemStack stack) {
float efficiency = 8.0F;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED)) {
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED_II)) {
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.SPEED_III)) {
2015-10-03 10:19:40 +02:00
efficiency += 37.0F;
2019-05-02 09:10:29 +02:00
} else {
2015-10-03 10:19:40 +02:00
efficiency += 25.0F;
2015-06-15 22:06:07 +02:00
}
2019-05-02 09:10:29 +02:00
} else {
2015-10-03 10:19:40 +02:00
efficiency += 8.0F;
}
2015-06-15 22:06:07 +02:00
}
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.THREE_BY_THREE)) {
2016-06-09 21:14:43 +02:00
efficiency *= 0.5F;
2019-05-02 09:10:29 +02:00
if (this.getHasUpgrade(stack, ItemDrillUpgrade.UpgradeType.FIVE_BY_FIVE)) {
2016-06-09 21:14:43 +02:00
efficiency *= 0.35F;
}
}
2015-10-03 10:19:40 +02:00
return efficiency;
2015-06-15 22:06:07 +02:00
}
/**
* Breaks Blocks in a certain Radius
* Has to be called on both Server and Client
2015-10-02 16:48:01 +02:00
*
* @param stack The Drill
* @param radius The Radius to break Blocks in (0 means only 1 Block will be broken!)
2015-10-02 16:48:01 +02:00
* @param world The World
* @param player The Player who breaks the Blocks
*/
2021-02-26 22:15:48 +01:00
public boolean breakBlocks(ItemStack stack, int radius, World world, BlockPos aPos, EnumFacing side, PlayerEntity player) {
2015-06-15 22:06:07 +02:00
int xRange = radius;
int yRange = radius;
int zRange = 0;
2015-07-20 22:06:08 +02:00
//Corrects Blocks to hit depending on Side of original Block hit
2019-05-02 09:10:29 +02:00
if (side.getAxis() == Axis.Y) {
2015-07-20 22:06:08 +02:00
zRange = radius;
yRange = 0;
}
2019-05-02 09:10:29 +02:00
if (side.getAxis() == Axis.X) {
2015-07-20 22:06:08 +02:00
xRange = 0;
zRange = radius;
}
2015-06-15 22:06:07 +02:00
2015-07-20 22:06:08 +02:00
//Not defined later because main Block is getting broken below
2021-02-26 22:15:48 +01:00
BlockState state = world.getBlockState(aPos);
2016-07-04 20:15:41 +02:00
float mainHardness = state.getBlockHardness(world, aPos);
2015-07-20 22:06:08 +02:00
//Break Middle Block first
int use = this.getEnergyUsePerBlock(stack);
2019-05-02 09:10:29 +02:00
if (this.getEnergyStored(stack) >= use) {
2021-02-26 22:15:48 +01:00
if (!this.tryHarvestBlock(world, aPos, false, stack, player, use)) {
return false;
}
2019-05-02 09:10:29 +02:00
} else {
2015-10-02 16:48:01 +02:00
return false;
}
2019-02-27 19:53:05 +01:00
2019-05-02 09:10:29 +02:00
if (radius == 2 && side.getAxis() != Axis.Y) {
2019-02-27 19:53:05 +01:00
aPos = aPos.up();
2021-02-26 22:15:48 +01:00
BlockState theState = world.getBlockState(aPos);
2019-05-02 09:10:29 +02:00
if (theState.getBlockHardness(world, aPos) <= mainHardness + 5.0F) {
2019-02-27 19:53:05 +01:00
this.tryHarvestBlock(world, aPos, true, stack, player, use);
}
}
2015-07-20 22:06:08 +02:00
//Break Blocks around
2019-05-02 09:10:29 +02:00
if (radius > 0 && mainHardness >= 0.2F) {
for (int xPos = aPos.getX() - xRange; xPos <= aPos.getX() + xRange; xPos++) {
for (int yPos = aPos.getY() - yRange; yPos <= aPos.getY() + yRange; yPos++) {
for (int zPos = aPos.getZ() - zRange; zPos <= aPos.getZ() + zRange; zPos++) {
if (!(aPos.getX() == xPos && aPos.getY() == yPos && aPos.getZ() == zPos)) {
if (this.getEnergyStored(stack) >= use) {
2015-07-20 22:06:08 +02:00
//Only break Blocks around that are (about) as hard or softer
2016-01-08 13:31:58 +01:00
BlockPos thePos = new BlockPos(xPos, yPos, zPos);
2021-02-26 22:15:48 +01:00
BlockState theState = world.getBlockState(thePos);
2019-05-02 09:10:29 +02:00
if (theState.getBlockHardness(world, thePos) <= mainHardness + 5.0F) {
this.tryHarvestBlock(world, thePos, true, stack, player, use);
}
2019-05-02 09:10:29 +02:00
} else {
2015-10-02 16:48:01 +02:00
return false;
}
2015-06-15 22:06:07 +02:00
}
}
}
}
}
2015-07-20 22:06:08 +02:00
return true;
}
/**
* Tries to harvest a certain Block
* Breaks the Block, drops Particles etc.
* Has to be called on both Server and Client
2015-10-02 16:48:01 +02:00
*
* @param world The World
* @param isExtra If the Block is the Block that was looked at when breaking or an additional Block
2015-10-02 16:48:01 +02:00
* @param stack The Drill
* @param player The Player breaking the Blocks
* @param use The Energy that should be extracted per Block
*/
2021-02-26 22:15:48 +01:00
private boolean tryHarvestBlock(World world, BlockPos pos, boolean isExtra, ItemStack stack, PlayerEntity player, int use) {
BlockState state = world.getBlockState(pos);
2016-07-04 20:15:41 +02:00
Block block = state.getBlock();
float hardness = state.getBlockHardness(world, pos);
2018-01-31 06:07:29 +01:00
boolean canHarvest = (ForgeHooks.canHarvestBlock(block, player, world, pos) || this.canHarvestBlock(state, stack)) && (!isExtra || this.getDestroySpeed(stack, world.getBlockState(pos)) > 1.0F);
2019-05-02 09:10:29 +02:00
if (hardness >= 0.0F && (!isExtra || canHarvest && !block.hasTileEntity(world.getBlockState(pos)))) {
2021-02-28 15:47:54 +01:00
if (!player.isCreative()) {
this.extractEnergyInternal(stack, use, false);
}
//Break the Block
return WorldUtil.breakExtraBlock(stack, world, player, pos);
}
2015-07-20 22:06:08 +02:00
return false;
2015-06-15 22:06:07 +02:00
}
2019-05-02 09:10:29 +02:00
private boolean hasExtraWhitelist(Block block) {
if (block != null) {
ResourceLocation location = block.getRegistryName();
2019-05-02 09:10:29 +02:00
if (location != null) {
String name = location.toString();
2019-05-02 09:10:29 +02:00
if (name != null) {
for (String s : ConfigStringListValues.DRILL_EXTRA_MINING_WHITELIST.getValue()) {
2021-02-26 22:15:48 +01:00
if (s != null && s.equals(name)) {
return true;
}
}
2015-10-03 10:16:18 +02:00
}
}
}
return false;
}
2019-02-27 19:53:05 +01:00
2017-08-12 00:15:09 +02:00
@Override
public boolean shouldCauseBlockBreakReset(ItemStack oldStack, ItemStack newStack) {
2019-02-27 19:53:05 +01:00
return !newStack.isItemEqual(oldStack);
2017-08-12 00:15:09 +02:00
}
2015-06-15 22:06:07 +02:00
}