src/main/java/mekanism/common/item/ItemAtomicDisassembler.java

package mekanism.common.item;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import mekanism.api.Coord4D;
import mekanism.api.EnumColor;
import mekanism.api.util.ListUtils;
import mekanism.common.util.MekanismUtils;
import net.minecraft.block.Block;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.DamageSource;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.event.entity.player.UseHoeEvent;
import cpw.mods.fml.common.eventhandler.Event.Result;

public class ItemAtomicDisassembler extends ItemEnergized
{
	public double ENERGY_USAGE = 10;
	public double HOE_USAGE = 100;

	public ItemAtomicDisassembler()
	{
		super(1000000);
	}

	@Override
	public void registerIcons(IIconRegister register) {}

	@Override
	public boolean canHarvestBlock(Block block, ItemStack stack)
	{
		return block != Blocks.bedrock;
	}

	@Override
	public void addInformation(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag)
	{
		super.addInformation(itemstack, entityplayer, list, flag);

		list.add(MekanismUtils.localize("tooltip.mode") + ": " + EnumColor.INDIGO + getModeName(itemstack));
		list.add(MekanismUtils.localize("tooltip.efficiency") + ": " + EnumColor.INDIGO + getEfficiency(itemstack));
	}

	@Override
	public boolean hitEntity(ItemStack itemstack, EntityLivingBase hitEntity, EntityLivingBase player)
	{
		if(getEnergy(itemstack) > 0)
		{
			hitEntity.attackEntityFrom(DamageSource.causePlayerDamage((EntityPlayer)player), 20);
			setEnergy(itemstack, getEnergy(itemstack) - 2000);
		}
		else {
			hitEntity.attackEntityFrom(DamageSource.causePlayerDamage((EntityPlayer)player), 4);
		}

		return false;
	}

	@Override
	public float getDigSpeed(ItemStack itemstack, Block block, int meta)
	{
		return getEnergy(itemstack) != 0 ? getEfficiency(itemstack) : 1F;
	}

	@Override
	public boolean onBlockDestroyed(ItemStack itemstack, World world, Block block, int x, int y, int z, EntityLivingBase entityliving)
	{
		if(block.getBlockHardness(world, x, y, z) != 0.0D)
		{
			setEnergy(itemstack, getEnergy(itemstack) - (ENERGY_USAGE*getEfficiency(itemstack)));
		}
		else {
			setEnergy(itemstack, getEnergy(itemstack) - (ENERGY_USAGE*(getEfficiency(itemstack))/2));
		}

		return true;
	}

	@Override
	public boolean onBlockStartBreak(ItemStack itemstack, int x, int y, int z, EntityPlayer player)
	{
		super.onBlockStartBreak(itemstack, x, y, z, player);

		if(!player.worldObj.isRemote)
		{
			Block block = player.worldObj.getBlock(x, y, z);
			int meta = player.worldObj.getBlockMetadata(x, y, z);
			
			if(block == Blocks.lit_redstone_ore)
			{
				block = Blocks.redstone_ore;
			}

			ItemStack stack = new ItemStack(block, 1, meta);
			Coord4D orig = new Coord4D(x, y, z, player.worldObj.provider.dimensionId);

			List<String> names = MekanismUtils.getOreDictName(stack);

			boolean isOre = false;

			for(String s : names)
			{
				if(s.startsWith("ore") || s.equals("logWood"))
				{
					isOre = true;
				}
			}

			if(getMode(itemstack) == 3 && isOre && !player.capabilities.isCreativeMode)
			{
				Set<Coord4D> found = new Finder(player.worldObj, stack, new Coord4D(x, y, z, player.worldObj.provider.dimensionId)).calc();

				for(Coord4D coord : found)
				{
					if(coord.equals(orig) || getEnergy(itemstack) < (ENERGY_USAGE*getEfficiency(itemstack)))
					{
						continue;
					}

					Block block2 = coord.getBlock(player.worldObj);

					block2.onBlockDestroyedByPlayer(player.worldObj, coord.xCoord, coord.yCoord, coord.zCoord, meta);
					player.worldObj.playAuxSFXAtEntity(null, 2001, coord.xCoord, coord.yCoord, coord.zCoord, meta << 12);
					player.worldObj.setBlockToAir(coord.xCoord, coord.yCoord, coord.zCoord);
					block2.breakBlock(player.worldObj, coord.xCoord, coord.yCoord, coord.zCoord, block, meta);
					block2.dropBlockAsItem(player.worldObj, coord.xCoord, coord.yCoord, coord.zCoord, meta, 0);

					setEnergy(itemstack, getEnergy(itemstack) - (ENERGY_USAGE*getEfficiency(itemstack)));
				}
			}
		}

		return false;
	}

	@Override
	public boolean isFull3D()
	{
		return true;
	}

	@Override
	public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer entityplayer)
	{
		if(!world.isRemote && entityplayer.isSneaking())
		{
			toggleMode(itemstack);
			entityplayer.addChatMessage(new ChatComponentText(EnumColor.DARK_BLUE + "[Mekanism] " + EnumColor.GREY + MekanismUtils.localize("tooltip.modeToggle") + " " + EnumColor.INDIGO + getModeName(itemstack) + EnumColor.AQUA + " (" + getEfficiency(itemstack) + ")"));
		}

		return itemstack;
	}

	@Override
	public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ)
	{
		if(!player.isSneaking())
		{
			if(!useHoe(stack, player, world, x, y, z, side))
			{
				if(world.getBlock(x, y, z) != Blocks.farmland)
				{
					return false;
				}
			}

			switch(getEfficiency(stack))
			{
				case 20:
					for(int x1 = x-1; x1 <= x+1; x1++)
					{
						for(int z1 = z-1; z1 <= z+1; z1++)
						{
							useHoe(stack, player, world, x1, y, z1, side);
						}
					}

					break;
				case 128:
					for(int x1 = x-2; x1 <= x+2; x1++)
					{
						for(int z1 = z-2; z1 <= z+2; z1++)
						{
							useHoe(stack, player, world, x1, y, z1, side);
						}
					}

					break;
			}

			return true;
		}

		return false;
	}

	private boolean useHoe(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side)
	{
		if(!player.canPlayerEdit(x, y, z, side, stack) || (!player.capabilities.isCreativeMode && getEnergy(stack) < HOE_USAGE))
		{
			return false;
		}
		else {
			UseHoeEvent event = new UseHoeEvent(player, stack, world, x, y, z);

			if(MinecraftForge.EVENT_BUS.post(event))
			{
				return false;
			}

			if(event.getResult() == Result.ALLOW)
			{
				setEnergy(stack, getEnergy(stack)-HOE_USAGE);
				return true;
			}

			Block block1 = world.getBlock(x, y, z);
			boolean air = world.isAirBlock(x, y + 1, z);

			if(side != 0 && air && (block1 == Blocks.grass || block1 == Blocks.dirt))
			{
				Block farm = Blocks.farmland;
				world.playSoundEffect(x + 0.5F, y + 0.5F, z + 0.5F, farm.stepSound.getStepResourcePath(), (farm.stepSound.getVolume() + 1.0F) / 2.0F, farm.stepSound.getPitch() * 0.8F);

				if(world.isRemote)
				{
					return true;
				}
				else {
					world.setBlock(x, y, z, farm);
					
					if(!player.capabilities.isCreativeMode)
					{
						setEnergy(stack, getEnergy(stack)-HOE_USAGE);
					}
					
					return true;
				}
			}
			else {
				return false;
			}
		}
	}

	public int getEfficiency(ItemStack itemStack)
	{
		switch(getMode(itemStack))
		{
			case 0:
				return 20;
			case 1:
				return 8;
			case 2:
				return 128;
			case 3:
				return 20;
			case 4:
				return 0;
		}

		return 0;
	}

	public int getMode(ItemStack itemStack)
	{
		if(itemStack.stackTagCompound == null)
		{
			return 0;
		}

		return itemStack.stackTagCompound.getInteger("mode");
	}

	public String getModeName(ItemStack itemStack)
	{
		int mode = getMode(itemStack);

		switch(mode)
		{
			case 0:
				return MekanismUtils.localize("tooltip.disassembler.normal");
			case 1:
				return MekanismUtils.localize("tooltip.disassembler.slow");
			case 2:
				return MekanismUtils.localize("tooltip.disassembler.fast");
			case 3:
				return MekanismUtils.localize("tooltip.disassembler.vein");
			case 4:
				return MekanismUtils.localize("tooltip.disassembler.off");
		}

		return null;
	}

	public void toggleMode(ItemStack itemStack)
	{
		if(itemStack.stackTagCompound == null)
		{
			itemStack.setTagCompound(new NBTTagCompound());
		}

		itemStack.stackTagCompound.setInteger("mode", getMode(itemStack) < 4 ? getMode(itemStack)+1 : 0);
	}

	@Override
	public boolean canSend(ItemStack itemStack)
	{
		return false;
	}

	public static class Finder
	{
		public World world;

		public ItemStack stack;

		public Coord4D location;

		public Set<Coord4D> found = new HashSet<Coord4D>();

		public static Map<Block, List<Block>> ignoreBlocks = new HashMap<Block, List<Block>>();

		public Finder(World w, ItemStack s, Coord4D loc)
		{
			world = w;
			stack = s;
			location = loc;
		}

		public void loop(Coord4D pointer)
		{
			if(found.contains(pointer) || found.size() > 128)
			{
				return;
			}

			found.add(pointer);

			for(ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
			{
				Coord4D coord = pointer.getFromSide(side);

				if(coord.exists(world) && checkID(coord.getBlock(world)) && (coord.getMetadata(world) == stack.getItemDamage() || (MekanismUtils.getOreDictName(stack).contains("logWood") && coord.getMetadata(world) % 4 == stack.getItemDamage() % 4)))
				{
					loop(coord);
				}
			}
		}

		public Set<Coord4D> calc()
		{
			loop(location);

			return found;
		}

		public boolean checkID(Block b)
		{
			Block origBlock = location.getBlock(world);
			return (ignoreBlocks.get(origBlock) == null && b == origBlock) || (ignoreBlocks.get(origBlock) != null && ignoreBlocks.get(origBlock).contains(b));
		}

		static {
			ignoreBlocks.put(Blocks.redstone_ore, ListUtils.asList(Blocks.redstone_ore, Blocks.lit_redstone_ore));
			ignoreBlocks.put(Blocks.lit_redstone_ore, ListUtils.asList(Blocks.redstone_ore, Blocks.lit_redstone_ore));
		}
	}
}