BlockTree.java

package bspkrs.treecapitator;

import java.util.ArrayList;
import java.util.List;
import net.minecraft.src.Block;
import net.minecraft.src.BlockLeavesBase;
import net.minecraft.src.BlockLog;
import net.minecraft.src.BlockVine;
import net.minecraft.src.EntityPlayer;
import net.minecraft.src.ItemStack;
import net.minecraft.src.World;
import bspkrs.util.*;

public class BlockTree extends BlockLog
{
    private EntityPlayer player;
    private boolean shouldFell;
    private Coord startPos;
    private float axeDamage;
    private int currentAxeDamage;
    private ItemStack axe;
    private float shearDamage;
    private int currentShearDamage;
    private ItemStack shears;

    public BlockTree(int i)
    {
        super(i);
        setHardness(TreeCapitator.logHardnessNormal);
        setStepSound(Block.soundWoodFootstep);
        setBlockName("log");
        setRequiresSelfNotify();
        shouldFell = false;
    }

    /**
     * Called when the block is clicked by a player. Args: x, y, z, entityPlayer
     */
    @Override
    public void onBlockClicked(World world, int x, int y, int z, EntityPlayer entityPlayer)
    {
        player = entityPlayer;
        shouldFell = false;

        if ((!TreeCapitator.needItem || isAxeItemEquipped(entityPlayer)) && !world.isRemote)
        {
            blockHardness = TreeCapitator.logHardnessModified;

            if(axe != null)
                currentAxeDamage = axe.getMaxDamage() + 1 - axe.getItemDamage();
            else
                currentAxeDamage = 0;

            shouldFell = true;

            if(!entityPlayer.capabilities.isCreativeMode && TreeCapitator.allowItemDamage && axe != null && currentAxeDamage <= 1)
                shouldFell = false;
        }
        else
        {
            blockHardness = TreeCapitator.logHardnessNormal;
        }
    }

    /**
     * Called when the block is attempted to be harvested
     */
    @Override
    public void onBlockHarvested(World world, int x, int y, int z, int md, EntityPlayer entityPlayer)
    {
        player = entityPlayer;
        startPos = new Coord(x, y, z);

        if(((TreeCapitator.sneakAction.equalsIgnoreCase("enable") && player.isSneaking())
                || (!TreeCapitator.sneakAction.toLowerCase().contains("enable") && !player.isSneaking()))
                && !world.isRemote && !(player.capabilities.isCreativeMode && TreeCapitator.disableInCreative))
        {
            Coord topLog = getTopLog(world, new Coord(x, y, z));
            if (leavesAround(world, topLog) > 2 && shouldFell)
            {
                List<Coord> listFinal = new ArrayList<Coord>();
                List<Coord> logs = addLogs(world, new Coord(x, y, z));
                addLogsAbove(world, new Coord(x, y, z), listFinal);
                destroyBlocks(world, logs);
                if (TreeCapitator.destroyLeaves)
                {
                    for(Coord pos : listFinal)
                    {
                        List<Coord> leaves = addLeaves(world, pos);
                        removeLeavesWithLogsAround(world, leaves);
                        destroyBlocksWithChance(world, leaves, 0.5F, playerHasShearsInHotbar(player));
                    }
                }
            }
        }
    }

    public Coord getTopLog(World world, Coord pos)
    {
        while(world.getBlockId(pos.x, pos.y + 1, pos.z) == blockID)
            pos.y++;
        return pos;
    }

    public int leavesAround(World world, Coord pos)
    {
        int i = 0;
        for (int x = -1; x <= 1; x++)
        {
            for (int y = -1; y <= 1; y++)
            {
                for (int z = -1; z <= 1; z++)
                {
                    if (x != 0 || y != 0 || z != 0)
                    {
                        Block block = Block.blocksList[world.getBlockId(pos.x + x, pos.y + y, pos.z + z)];
                        if (block != null && (block instanceof BlockLeavesBase))
                            i++;
                    }
                }
            }
        }

        return i;
    }

    /**
     * Defines whether or not a player can break the block with current tool and sets the local axe object if possible
     */
    private boolean isAxeItemEquipped(EntityPlayer entityPlayer)
    {
        ItemStack item = entityPlayer.getCurrentEquippedItem();
        if(item != null && CommonUtils.isItemInList(item.itemID, item.getItemDamage(), TreeCapitator.axeIDList))
        {
            axe = item;
            return true;
        }
        else
        {
            axe = null;
            return false;
        }
    }

    /**
     * Defines whether or not a player has a shear-type item in the hotbar
     */
    private boolean playerHasShearsInHotbar(EntityPlayer entityplayer)
    {

        return shearsHotbarIndex(entityplayer) != -1;
    }

    /**
     * Returns the index of the left-most shear-type item in the hotbar and sets the local shears object if possible
     */
    private int shearsHotbarIndex(EntityPlayer entityPlayer)
    {
        for(int i = 0; i < 9; i++)
        {
            ItemStack item = entityPlayer.inventory.mainInventory[i];

            if(item != null && CommonUtils.isItemInList(item.itemID, item.getItemDamage(), TreeCapitator.shearIDList))
            {
                shears = item;
                return i;
            }
        }
        shears = null;
        return -1;
    }

    private void destroyBlocks(World world, List<Coord> list)
    {
        destroyBlocksWithChance(world, list, 1.0F, false);
    }

    private void destroyBlocksWithChance(World world, List<Coord> list, float f, boolean canShear)
    {
        while (list.size() > 0)
        {
            Coord pos = list.remove(0);
            int id = world.getBlockId(pos.x, pos.y, pos.z);
            if(id != 0)
            {
                Block block = Block.blocksList[id];
                int metadata = world.getBlockMetadata(pos.x, pos.y, pos.z);
                world.setBlockWithNotify(pos.x, pos.y, pos.z, 0);

                if((((block instanceof BlockVine && TreeCapitator.shearVines) || (block instanceof BlockLeavesBase && TreeCapitator.shearLeaves)) && canShear)
                        && !(player.capabilities.isCreativeMode && TreeCapitator.disableCreativeDrops))
                {
                    dropBlockAsItem_do(world, pos.x, pos.y, pos.z, new ItemStack(id, 1, metadata & 0x03));

                }
                else if(!(player.capabilities.isCreativeMode && TreeCapitator.disableCreativeDrops))
                {
                    block.dropBlockAsItem(world, pos.x, pos.y, pos.z, metadata, 0);
                }
            }
        }
    }

    public List addLogs(World world, Coord pos)
    {
        int index = 0, lowY = pos.y, x, y, z;
        List<Coord> list = new ArrayList<Coord>();
        Coord newPos;

        list.add(pos);

        do
        {
            Coord currentLog = list.get(index);

            for (x = -1; x <= 1; x++)
            {
                for (y = -1; y <= 1; y++)
                {
                    for (z = -1; z <= 1; z++)
                    {
                        if (world.getBlockId(currentLog.x + x, currentLog.y + y, currentLog.z + z) == this.blockID)
                        {
                            newPos = new Coord(currentLog.x + x, currentLog.y + y, currentLog.z + z);

                            if(TreeCapitator.maxBreakDistance == -1
                                    || (Math.abs(newPos.x - startPos.x) <= TreeCapitator.maxBreakDistance
                                        &&  Math.abs(newPos.z - startPos.z) <= TreeCapitator.maxBreakDistance))

                            if (!list.contains(newPos) && (newPos.y >= lowY || !TreeCapitator.onlyDestroyUpwards))
                                list.add(newPos);
                        }
                    }
                }
            }
        } while (++index < list.size());

        return list;
    }

    private void addLogsAbove(World world, Coord position, List<Coord> listFinal)
    {
        List<Coord> listAbove = new ArrayList<Coord>();
        List<Coord> list;
        Coord newPosition;
        int counter, index, x, z;

        listAbove.add(position);

        do
        {
            list = listAbove;
            listAbove = new ArrayList<Coord>();

            for (Coord pos : list)
            {
                counter = 0;
                for (x = -1; x <= 1; x++)
                {
                    for (z = -1; z <= 1; z++)
                    {
                        if (world.getBlockId(pos.x + x, pos.y + 1, pos.z + z) == this.blockID)
                        {
                            if (!listAbove.contains(newPosition = new Coord(pos.x + x, pos.y + 1, pos.z + z)))
                            {
                                listAbove.add(newPosition);
                            }
                            counter++;
                        }
                    }
                }

                if (counter == 0)
                {
                    listFinal.add(pos.clone());
                }
            }

            index = -1;
            while (++index < listAbove.size())
            {
                Coord pos = listAbove.get(index);
                for (x = -1; x <= 1; x++)
                {
                    for (z = -1; z <= 1; z++)
                    {
                        if (world.getBlockId(pos.x + x, pos.y, pos.z + z) == this.blockID)
                        {
                            if (!listAbove.contains(newPosition = new Coord(pos.x + x, pos.y, pos.z + z)))
                            {
                                listAbove.add(newPosition);
                            }
                        }
                    }
                }
            }
        } while (listAbove.size() > 0);
    }

    public List<Coord> addLeaves(World world, Coord pos)
    {
        int index = -1;
        List<Coord> list = new ArrayList<Coord>();

        addLeavesInDistance(world, pos, 4, list);

        while (++index < list.size())
        {
            Coord var5 = list.get(index);
            addLeavesInDistance(world, var5, 1, list);
        }

        return list;
    }

    public void addLeavesInDistance(World world, Coord pos, int range, List list)
    {
        for (int x = -range; x <= range; x++)
        {
            for (int y = -range; y <= range; y++)
            {
                for (int z = -range; z <= range; z++)
                {
                    Block block = Block.blocksList[world.getBlockId(x + pos.x, y + pos.y, z + pos.z)];
                    if (block != null && (block instanceof BlockLeavesBase || block instanceof BlockVine))
                    {
                        int metadata = world.getBlockMetadata(x + pos.x, y + pos.y, z + pos.z);
                        if ((metadata & 8) != 0 && (metadata & 4) == 0)
                        {
                            Coord newPos = new Coord(x + pos.x, y + pos.y, z + pos.z);
                            if (!list.contains(newPos))
                            {
                                list.add(newPos);
                            }
                        }
                    }
                }
            }
        }
    }

    public void removeLeavesWithLogsAround(World world, List<Coord> list)
    {
        for (int i = 0; i < list.size();)
            if (hasLogClose(world, list.get(i), 1))
                list.remove(i);
            else
                i++;
    }

    public boolean hasLogClose(World world, Coord pos, int i)
    {
        for (int x = -i; x <= i; x++)
            for (int y = -i; y <= i; y++)
                for (int z = -i; z <= i; z++)
                    if ((x != 0 || y != 0 || z != 0) && world.getBlockId(x + pos.x, y + pos.y, z + pos.z) == this.blockID)
                        return true;

        return false;
    }
}