Files
Botania/src/main/java/vazkii/botania/common/item/rod/ItemExchangeRod.java
T

393 lines
14 KiB
Java

/**
* This class was created by <Vazkii>. It's distributed as
* part of the Botania Mod. Get the Source Code in github:
* https://github.com/Vazkii/Botania
*
* Botania is Open Source and distributed under the
* Botania License: http://botaniamod.net/license.php
*
* File Created @ [Aug 20, 2015, 8:08:34 PM (GMT)]
*/
package vazkii.botania.common.item.rod;
import com.google.common.collect.ImmutableList;
import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemUseContext;
import net.minecraft.nbt.NBTUtil;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ActionResultType;
import net.minecraft.util.Direction;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.BlockRayTraceResult;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextFormatting;
import net.minecraft.world.World;
import net.minecraftforge.api.distmarker.Dist;
import net.minecraftforge.api.distmarker.OnlyIn;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.util.LazyOptional;
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.IItemHandler;
import vazkii.botania.api.BotaniaAPI;
import vazkii.botania.api.item.IBlockProvider;
import vazkii.botania.api.item.IManaProficiencyArmor;
import vazkii.botania.api.item.IWireframeCoordinateListProvider;
import vazkii.botania.api.mana.IManaUsingItem;
import vazkii.botania.api.mana.ManaItemHandler;
import vazkii.botania.client.core.handler.ItemsRemainingRenderHandler;
import vazkii.botania.common.block.BlockPlatform;
import vazkii.botania.common.core.helper.ItemNBTHelper;
import net.minecraft.item.Item;
import javax.annotation.Nonnull;
import java.util.ArrayList;
import java.util.List;
public class ItemExchangeRod extends Item implements IManaUsingItem, IWireframeCoordinateListProvider {
private static final int RANGE = 3;
private static final int COST = 40;
private static final String TAG_BLOCK_NAME = "blockName";
private static final String TAG_TARGET_BLOCK_NAME = "targetState";
private static final String TAG_SWAPPING = "swapping";
private static final String TAG_SELECT_X = "selectX";
private static final String TAG_SELECT_Y = "selectY";
private static final String TAG_SELECT_Z = "selectZ";
private static final String TAG_EXTRA_RANGE = "extraRange";
public ItemExchangeRod(Properties props) {
super(props);
MinecraftForge.EVENT_BUS.addListener(this::onLeftClick);
}
@Nonnull
@Override
public ActionResultType onItemUse(ItemUseContext ctx) {
World world = ctx.getWorld();
BlockPos pos = ctx.getPos();
PlayerEntity player = ctx.getPlayer();
ItemStack stack = ctx.getItem();
BlockState wstate = world.getBlockState(pos);
if(player != null && player.isSneaking()) {
TileEntity tile = world.getTileEntity(pos);
if(tile == null) {
if(BlockPlatform.isValidBlock(wstate, world, pos)) {
setBlock(stack, wstate);
displayRemainderCounter(player, stack);
return ActionResultType.SUCCESS;
}
}
} else if(canExchange(stack) && !ItemNBTHelper.getBoolean(stack, TAG_SWAPPING, false)) {
BlockState state = getState(stack);
List<BlockPos> swap = getBlocksToSwap(world, stack, state, pos, null);
if(swap.size() > 0) {
ItemNBTHelper.setBoolean(stack, TAG_SWAPPING, true);
ItemNBTHelper.setInt(stack, TAG_SELECT_X, pos.getX());
ItemNBTHelper.setInt(stack, TAG_SELECT_Y, pos.getY());
ItemNBTHelper.setInt(stack, TAG_SELECT_Z, pos.getZ());
setTarget(stack, wstate);
}
}
return ActionResultType.SUCCESS;
}
private void onLeftClick(PlayerInteractEvent.LeftClickBlock event) {
ItemStack stack = event.getItemStack();
if(!stack.isEmpty() && stack.getItem() == this && canExchange(stack) && ManaItemHandler.requestManaExactForTool(stack, event.getPlayer(), COST, false)) {
if(exchange(event.getWorld(), event.getPlayer(), event.getPos(), stack, getState(stack)))
ManaItemHandler.requestManaExactForTool(stack, event.getPlayer(), COST, true);
}
}
@Override
public void inventoryTick(ItemStack stack, World world, Entity entity, int slot, boolean equipped) {
if(!canExchange(stack) || !(entity instanceof PlayerEntity))
return;
PlayerEntity player = (PlayerEntity) entity;
int extraRange = ItemNBTHelper.getInt(stack, TAG_EXTRA_RANGE, 1);
int extraRangeNew = IManaProficiencyArmor.Helper.hasProficiency(player, stack) ? 3 : 1;
if(extraRange != extraRangeNew)
ItemNBTHelper.setInt(stack, TAG_EXTRA_RANGE, extraRangeNew);
BlockState state = getState(stack);
if(ItemNBTHelper.getBoolean(stack, TAG_SWAPPING, false)) {
if(!ManaItemHandler.requestManaExactForTool(stack, player, COST, false)) {
ItemNBTHelper.setBoolean(stack, TAG_SWAPPING, false);
return;
}
int x = ItemNBTHelper.getInt(stack, TAG_SELECT_X, 0);
int y = ItemNBTHelper.getInt(stack, TAG_SELECT_Y, 0);
int z = ItemNBTHelper.getInt(stack, TAG_SELECT_Z, 0);
BlockState target = getTargetState(stack);
List<BlockPos> swap = getBlocksToSwap(world, stack, state, new BlockPos(x, y, z), target);
if(swap.size() == 0) {
ItemNBTHelper.setBoolean(stack, TAG_SWAPPING, false);
return;
}
BlockPos coords = swap.get(world.rand.nextInt(swap.size()));
boolean exchange = exchange(world, player, coords, stack, state);
if(exchange)
ManaItemHandler.requestManaExactForTool(stack, player, COST, true);
else ItemNBTHelper.setBoolean(stack, TAG_SWAPPING, false);
}
}
public List<BlockPos> getBlocksToSwap(World world, ItemStack stack, BlockState swapState, BlockPos pos, BlockState targetState) {
// If we have no target block passed in, infer it to be
// the block which the swapping is centered on (presumably the block
// which the player is looking at)
if(targetState == null) {
targetState = world.getBlockState(pos);
}
// Our result list
List<BlockPos> coordsList = new ArrayList<>();
// We subtract 1 from the effective range as the center tile is included
// So, with a range of 3, we are visiting tiles at -2, -1, 0, 1, 2
int effRange = RANGE + ItemNBTHelper.getInt(stack, TAG_EXTRA_RANGE, 1) - 1;
// Iterate in all 3 dimensions through our possible positions.
for(int offsetX = -effRange; offsetX <= effRange; offsetX++)
for(int offsetY = -effRange; offsetY <= effRange; offsetY++)
for(int offsetZ = -effRange; offsetZ <= effRange; offsetZ++) {
BlockPos pos_ = pos.add(offsetX, offsetY, offsetZ);
BlockState currentState = world.getBlockState(pos_);
// If this block is not our target, ignore it, as we don't need
// to consider replacing it
if(currentState != targetState)
continue;
// If this block is already the block we're swapping to,
// we don't need to swap again
if(currentState == swapState)
continue;
// Check to see if the block is visible on any side:
for(Direction dir : Direction.values()) {
BlockPos adjPos = pos_.offset(dir);
BlockState adjState = world.getBlockState(adjPos);
if(!Block.hasSolidSide(adjState, world, adjPos, dir.getOpposite())) {
coordsList.add(pos_);
break;
}
}
}
return coordsList;
}
public boolean exchange(World world, PlayerEntity player, BlockPos pos, ItemStack stack, BlockState state) {
TileEntity tile = world.getTileEntity(pos);
if(tile != null)
return false;
ItemStack placeStack = removeFromInventory(player, stack, state.getBlock(), false);
if(!placeStack.isEmpty()) {
BlockState stateAt = world.getBlockState(pos);
Block blockAt = stateAt.getBlock();
if(!blockAt.isAir(world.getBlockState(pos), world, pos) && stateAt.getPlayerRelativeBlockHardness(player, world, pos) > 0 && stateAt != state) {
if(!world.isRemote) {
world.destroyBlock(pos, !player.abilities.isCreativeMode);
if(!player.abilities.isCreativeMode) {
removeFromInventory(player, stack, state.getBlock(), true);
}
world.setBlockState(pos, state);
state.getBlock().onBlockPlacedBy(world, pos, state, player, placeStack);
}
displayRemainderCounter(player, stack);
return true;
}
}
return false;
}
public boolean canExchange(ItemStack stack) {
return !getState(stack).isAir();
}
public static ItemStack removeFromInventory(PlayerEntity player, LazyOptional<IItemHandler> inv, ItemStack stack, Block block, boolean doit) {
return inv.map(handler -> removeFromInventory(player, handler, stack, block, doit)).orElse(ItemStack.EMPTY);
}
public static ItemStack removeFromInventory(PlayerEntity player, IItemHandler inv, ItemStack stack, Block block, boolean doit) {
List<ItemStack> providers = new ArrayList<>();
for(int i = inv.getSlots() - 1; i >= 0; i--) {
ItemStack invStack = inv.getStackInSlot(i);
if(invStack.isEmpty())
continue;
Item item = invStack.getItem();
if(item == block.asItem()) {
return inv.extractItem(i, 1, !doit);
}
if(item instanceof IBlockProvider)
providers.add(invStack);
}
for(ItemStack provStack : providers) {
IBlockProvider prov = (IBlockProvider) provStack.getItem();
if(prov.provideBlock(player, stack, provStack, block, doit))
return new ItemStack(block);
}
return ItemStack.EMPTY;
}
public static ItemStack removeFromInventory(PlayerEntity player, ItemStack stack, Block block, boolean doit) {
if(player.abilities.isCreativeMode)
return new ItemStack(block);
ItemStack outStack = removeFromInventory(player, BotaniaAPI.internalHandler.getAccessoriesInventory(player), stack, block, doit);
if (outStack.isEmpty())
outStack = removeFromInventory(player, player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY), stack, block, doit);
return outStack;
}
public static int getInventoryItemCount(PlayerEntity player, ItemStack stack, Block block) {
if(player.abilities.isCreativeMode)
return -1;
int baubleCount = getInventoryItemCount(player, BotaniaAPI.internalHandler.getAccessoriesInventory(player), stack, block);
if (baubleCount == -1) return -1;
int count = getInventoryItemCount(player, player.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY), stack, block);
if (count == -1) return -1;
return count+baubleCount;
}
public static int getInventoryItemCount(PlayerEntity player, LazyOptional<IItemHandler> inv, ItemStack stack, Block block) {
return inv.map(handler -> getInventoryItemCount(player, handler, stack, block)).orElse(0);
}
public static int getInventoryItemCount(PlayerEntity player, IItemHandler inv, ItemStack stack, Block block) {
if(player.abilities.isCreativeMode)
return -1;
int count = 0;
for(int i = 0; i < inv.getSlots(); i++) {
ItemStack invStack = inv.getStackInSlot(i);
if(invStack.isEmpty())
continue;
Item item = invStack.getItem();
if(item == block.asItem())
count += invStack.getCount();
if(item instanceof IBlockProvider) {
IBlockProvider prov = (IBlockProvider) item;
int provCount = prov.getBlockCount(player, stack, invStack, block);
if(provCount == -1)
return -1;
count += provCount;
}
}
return count;
}
public void displayRemainderCounter(PlayerEntity player, ItemStack stack) {
Block block = getState(stack).getBlock();
int count = getInventoryItemCount(player, stack, block);
if(!player.world.isRemote)
ItemsRemainingRenderHandler.set(new ItemStack(block), count);
}
@Override
public boolean usesMana(ItemStack stack) {
return true;
}
private void setBlock(ItemStack stack, BlockState state) {
ItemNBTHelper.setCompound(stack, TAG_BLOCK_NAME, NBTUtil.writeBlockState(state));
}
@Nonnull
@Override
public ITextComponent getDisplayName(@Nonnull ItemStack stack) {
BlockState state = getState(stack);
ITextComponent cmp = super.getDisplayName(stack);
if (!state.isAir()) {
cmp.appendText(" (");
ITextComponent sub = new ItemStack(state.getBlock()).getDisplayName();
sub.getStyle().setColor(TextFormatting.GREEN);
cmp.appendSibling(sub);
cmp.appendText(")");
}
return cmp;
}
public static BlockState getState(ItemStack stack) {
return NBTUtil.readBlockState(ItemNBTHelper.getCompound(stack, TAG_BLOCK_NAME, false));
}
private void setTarget(ItemStack stack, BlockState state) {
ItemNBTHelper.setCompound(stack, TAG_TARGET_BLOCK_NAME, NBTUtil.writeBlockState(state));
}
public static BlockState getTargetState(ItemStack stack) {
return NBTUtil.readBlockState(ItemNBTHelper.getCompound(stack, TAG_TARGET_BLOCK_NAME, false));
}
@Override
@OnlyIn(Dist.CLIENT)
public List<BlockPos> getWireframesToDraw(PlayerEntity player, ItemStack stack) {
ItemStack holding = player.getHeldItemMainhand();
if(holding != stack || !canExchange(stack))
return ImmutableList.of();
BlockState state = getState(stack);
RayTraceResult pos = Minecraft.getInstance().objectMouseOver;
if(pos != null && pos.getType() == RayTraceResult.Type.BLOCK) {
BlockPos bPos = ((BlockRayTraceResult) pos).getPos();
BlockState target = null;
if(ItemNBTHelper.getBoolean(stack, TAG_SWAPPING, false)) {
bPos = new BlockPos(
ItemNBTHelper.getInt(stack, TAG_SELECT_X, 0),
ItemNBTHelper.getInt(stack, TAG_SELECT_Y, 0),
ItemNBTHelper.getInt(stack, TAG_SELECT_Z, 0)
);
target = getTargetState(stack);
}
if(!player.world.isAirBlock(bPos)) {
List<BlockPos> coordsList = getBlocksToSwap(player.world, stack, state, bPos, target);
coordsList.removeIf(bPos::equals);
return coordsList;
}
}
return ImmutableList.of();
}
@Override
public BlockPos getSourceWireframe(PlayerEntity player, ItemStack stack) {
return null;
}
}