Java Code Examples for net.minecraft.world.IBlockAccess

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess world,
		BlockPos pos) {
	
	int offset = 0;

	if(world.getBlockState(pos.add(1,0,0)).getBlock() == this)
		offset |= 0x1;
	if(world.getBlockState(pos.add(0,0,-1)).getBlock() == this)
		offset |= 0x2;
	if(world.getBlockState(pos.add(-1,0,0)).getBlock() == this)
		offset |= 0x4;
	if(world.getBlockState(pos.add(0,0,1)).getBlock() == this)
		offset |= 0x8;
	
	return state.withProperty(TYPE, IconNames.values()[offset]);
}
 

@Override
public void handleRenderBlockDamage(IBlockAccess world, BlockPos pos, IBlockState state, TextureAtlasSprite sprite, BufferBuilder buffer) {
    MetaTileEntity metaTileEntity = BlockMachine.getMetaTileEntity(world, pos);
    ArrayList<IndexedCuboid6> boundingBox = new ArrayList<>();
    if (metaTileEntity != null) {
        metaTileEntity.addCollisionBoundingBox(boundingBox);
        metaTileEntity.addCoverCollisionBoundingBox(boundingBox);
    }
    CCRenderState renderState = CCRenderState.instance();
    renderState.reset();
    renderState.bind(buffer);
    renderState.setPipeline(new Vector3(new Vec3d(pos)).translation(), new IconTransformation(sprite));
    for (Cuboid6 cuboid : boundingBox) {
        BlockRenderer.renderCuboid(renderState, cuboid, 0);
    }
}
 

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess world, BlockPos pos)
{
    state = super.getActualState(state, world, pos);

    TileEntityEnderFurnace te = getTileEntitySafely(world, pos, TileEntityEnderFurnace.class);

    if (te != null)
    {
        EnumMachineMode mode = te.isCookingLast == false ? EnumMachineMode.OFF :
            (te.isBurningLast == false ? EnumMachineMode.ON_NOFUEL : 
                te.fastMode ? EnumMachineMode.ON_FAST : EnumMachineMode.ON_NORMAL);

        state = state.withProperty(MODE, mode);
    }

    return state;
}
 

private IIcon getAccessPortIcon(IBlockAccess blockAccess, int x, int y,
		int z, int side) {
	TileEntity te = blockAccess.getTileEntity(x, y, z);
	if(te instanceof TileEntityReactorAccessPort) {
		TileEntityReactorAccessPort port = (TileEntityReactorAccessPort)te;

		if(!isReactorAssembled(port) || isOutwardsSide(port, side)) {
			if(port.isInlet()) {
				return _icons[METADATA_ACCESSPORT][PORT_INLET];
			}
			else {
				return _icons[METADATA_ACCESSPORT][PORT_OUTLET];
			}
		}
	}
	return blockIcon;
}
 

@SuppressWarnings("deprecation")
@Override
public boolean shouldSideBeRendered(IBlockState state, IBlockAccess blockAccess, BlockPos pos, EnumFacing side)
{
    IBlockState stateAdjacent = blockAccess.getBlockState(pos.offset(side));

    if (state != stateAdjacent)
    {
        return true;
    }
    else if (stateAdjacent.getBlock() == this)
    {
        return false;
    }

    return super.shouldSideBeRendered(state, blockAccess, pos, side);
}
 

public void getDrops(NonNullList<ItemStack> drops, IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
    Random rand = world instanceof World ? ((World) world).rand : RANDOM;

    int age = getAge(state);
    int count = quantityDropped(state, fortune, rand);
    for (int i = 0; i < count; i++) {
        Item item = this.getItemDropped(state, rand, fortune);
        if (item != Items.AIR) {
            drops.add(new ItemStack(item, 1, this.damageDropped(state)));
        }
    }

    if (age >= getMaxAge()) {
        int k = 3 + fortune;
        for (int i = 0; i < k; ++i) {
            if (rand.nextInt(2 * getMaxAge()) <= age) {
                drops.add(new ItemStack(this.getSeed(), 1, this.damageDropped(state)));
            }
        }
    }
}
 

private int getBaseBlockYCoord (IBlockAccess world, int x, int y, int z) {
    if (y == 0)
        return 0;

    Block underBlock = world.getBlock(x, --y, z);
    while (y > 0 && underBlock instanceof IPlantProxy)
        underBlock = world.getBlock(x, --y, z);

    return y;
}
 

public void renderOuterBlock(Block block, int x, int y, int z, RenderBlocks renderer, IBlockAccess world)
{

	Tessellator tessellator = Tessellator.instance;
	boolean tankUp = world.getBlockTileEntity(x, y + 1, z) instanceof TileEntityCertusTank;
	boolean tankDown = world.getBlockTileEntity(x, y - 1, z) instanceof TileEntityCertusTank;
	int meta = 0;
	if (tankUp && tankDown)
		meta = 3;
	else if (tankUp)
		meta = 2;
	else if (tankDown)
		meta = 1;
	if (!tankDown)
	{
		tessellator.setNormal(0.0F, -1F, 0.0F);
		renderer.renderFaceYNeg(block, x, y, z, block.getIcon(0, 0));
	}
	if (!(tankUp))
	{
		tessellator.setNormal(0.0F, 1.0F, 0.0F);
		renderer.renderFaceYPos(block, x, y, z, block.getIcon(1, 0));
	}

	Icon sideIcon = block.getIcon(3, meta);
	tessellator.setNormal(0.0F, 0.0F, -1F);
	renderer.renderFaceZNeg(block, x, y, z, sideIcon);
	tessellator.setNormal(0.0F, 0.0F, 1.0F);
	renderer.renderFaceZPos(block, x, y, z, sideIcon);
	tessellator.setNormal(-1F, 0.0F, 0.0F);
	renderer.renderFaceXNeg(block, x, y, z, sideIcon);
	tessellator.setNormal(1.0F, 0.0F, 0.0F);
	renderer.renderFaceXPos(block, x, y, z, sideIcon);

}
 

@SideOnly(Side.CLIENT)
@Override
public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos,
        EnumFacing side) {
    IBlockState iblockstate = blockAccess.getBlockState(pos.offset(side));
    Block block = iblockstate.getBlock();

    if (block == this || block == ModBlocks.clearplasticblock) {
        return false;
    }

    return block == this ? false : super.shouldSideBeRendered(blockState, blockAccess, pos, side);
}
 

@Override
public int isProvidingStrongPower(IBlockAccess access, BlockPos pos, IBlockState state, EnumFacing side) {
	Block blockInstance = getBlockInstance(access, VectorConverter.instance().toNova(pos));
	WrapperEvent.StrongRedstone event = new WrapperEvent.StrongRedstone(blockInstance.world(), blockInstance.position(), Direction.fromOrdinal(side.ordinal()));
	Game.events().publish(event);
	return event.power;
}
 

@Override
public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos)
{
    boolean flag = canWallConnectTo(worldIn, pos, EnumFacing.NORTH);
    boolean flag1 = canWallConnectTo(worldIn, pos, EnumFacing.EAST);
    boolean flag2 = canWallConnectTo(worldIn, pos, EnumFacing.SOUTH);
    boolean flag3 = canWallConnectTo(worldIn, pos, EnumFacing.WEST);
    boolean flag4 = flag && !flag1 && flag2 && !flag3 || !flag && flag1 && !flag2 && flag3;
    return state.withProperty(UP, !flag4 || !worldIn.isAirBlock(pos.up()))
                .withProperty(NORTH, flag)
                .withProperty(EAST, flag1)
                .withProperty(SOUTH, flag2)
                .withProperty(WEST, flag3);
}
 

public static boolean isHacked(IBlockAccess world, int x, int y, int z){
    TileEntity te = world.getTileEntity(x, y, z);
    if(te != null) {
        NBTTagCompound tag = new NBTTagCompound();
        te.writeToNBT(tag);
        if(tag.hasKey("RequiredPlayerRange") && tag.getShort("RequiredPlayerRange") == 0) return true;
    }
    return false;
}
 

@SideOnly(Side.CLIENT)
public boolean shouldSideBeRendered(IBlockState blockState, IBlockAccess blockAccess, BlockPos pos, EnumFacing side) {
    if (!Minecraft.getMinecraft().gameSettings.fancyGraphics) {
        if (!(blockAccess.getBlockState(pos.offset(side)).getBlock() instanceof BlockLeaves)) {
            return true;
        }
        return false;
    }
    return true;
}
 

public float getPlantOffsetY (IBlockAccess blockAccess, int x, int y, int z, int slot) {
    BlockGarden gardenBlock = getGardenBlock(blockAccess, x, y, z);
    if (gardenBlock == null)
        return 0;

    return gardenBlock.getSlotProfile().getPlantOffsetY(blockAccess, x, getBaseBlockYCoord(blockAccess, x, y, z), z, slot);
}
 

@Override
public BlockFaceShape getBlockFaceShape(IBlockAccess worldIn, IBlockState state, BlockPos pos, EnumFacing face)
{
    if (state.getValue(TYPE).isFullCube())
    {
        return BlockFaceShape.SOLID;
    }
    else
    {
        return BlockFaceShape.UNDEFINED;
    }
}
 

/**
 * Check for a world connection, if we're assembled.
 * @param world
 * @param x
 * @param y
 * @param z
 */
protected void checkForConnections(IBlockAccess world, int x, int y, int z) {
	boolean wasConnected = (rfNetwork != null);
	ForgeDirection out = getOutwardsDir();
	if(out == ForgeDirection.UNKNOWN) {
		wasConnected = false;
		rfNetwork = null;
	}
	else {
		// See if our adjacent non-reactor coordinate has a TE
		rfNetwork = null;

		TileEntity te = world.getTileEntity(x + out.offsetX, y + out.offsetY, z + out.offsetZ);
		if(!(te instanceof TileEntityReactorPowerTap)) {
			// Skip power taps, as they implement these APIs and we don't want to shit energy back and forth
			if(te instanceof IEnergyReceiver) {
				IEnergyReceiver handler = (IEnergyReceiver)te;
				if(handler.canConnectEnergy(out.getOpposite())) {
					rfNetwork = handler;
				}
			}
		}
	}
	
	boolean isConnected = (rfNetwork != null);
	if(wasConnected != isConnected && worldObj.isRemote) {
		// Re-render on clients
           worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
	}
}
 

/*******************************************************************************
 * 2. Rendering 
 *******************************************************************************/

@Override
public boolean isNormalCube(IBlockState state, IBlockAccess world, BlockPos pos)
{
	return false;
}
 

@Override
public void process(IBlockAccess iBlockAccess) {
    if (SideReference.Side.Client) {
        if (this.removal == 0)
            GT_TileEntity_BioVat.staticColorMap.put(this.coords, this.integer);
        else
            GT_TileEntity_BioVat.staticColorMap.remove(this.coords);
    }
}
 

@Override
public IBlockState getPlant(IBlockAccess world, BlockPos pos) 
{
	IBlockState state = world.getBlockState(pos);
	if (state.getBlock() != this) 
		return getDefaultState();
	return state;
}
 

public float getPlantOffsetX (IBlockAccess blockAccess, int x, int y, int z, int slot) {
    BlockGarden gardenBlock = getGardenBlock(blockAccess, x, y, z);
    if (gardenBlock == null)
        return 0;

    return gardenBlock.getSlotProfile().getPlantOffsetX(blockAccess, x, getBaseBlockYCoord(blockAccess, x, y, z), z, slot);
}
 

private TileMoving get(IBlockAccess w, int x, int y, int z) {

        TileEntity te = w.getTileEntity(x, y, z);
        if (te != null && te instanceof TileMoving)
            return (TileMoving) te;

        return null;
    }
 

@Override
public boolean renderWorldBlock (IBlockAccess world, int x, int y, int z, Block block, int modelId, RenderBlocks renderer) {
    if (block instanceof BlockSmallFire)
        return renderWorldBlock(world, x, y, z, (BlockSmallFire) block, modelId, renderer);

    return false;
}
 

private static boolean isConnected(IBlockAccess world, int x, int y, int z, int side, Block block, int meta)
{
    int x2 = x, y2 = y, z2 = z;

    switch(side)
    {
        case 0:
            y2--;
            break;
        case 1:
            y2++;
            break;
        case 2:
            z2--;
            break;
        case 3:
            z2++;
            break;
        case 4:
            x2--;
            break;
        case 5:
            x2++;
            break;
    }

    return getBlockOrFacade(world, x, y, z, side).equals(block) && getBlockOrFacadeMetadata(world, x, y, z, side) == meta && (!getBlockOrFacade(world, x2, y2, z2, side).equals(block) || getBlockOrFacadeMetadata(world, x2, y2, z2, side) != meta);
}
 

@Override
public boolean canSustainPlant(IBlockState state, IBlockAccess world, BlockPos pos, EnumFacing direction, IPlantable plantable)
{
	IBlockState plant = plantable.getPlant(world, pos.offset(direction));
	EnumPlantType plantType = plantable.getPlantType(world, pos.offset(direction));

	DesertCactusType veg = (DesertCactusType)state.getValue(META_PROPERTY);
	if(plant.getBlock() == this)
	{

	}
	return false;
}
 

public void setBlockAccess(IBlockAccess blockAccess) {
    this.blockAccess = blockAccess;
}
 

@Override
public AxisAlignedBB getBoundingBox(IBlockState state, IBlockAccess source, BlockPos pos)
{
	return new AxisAlignedBB(0.3, 0, 0.3, 0.7, 0.9, 0.7);
}
 

@Override
public boolean doesSideBlockRendering(IBlockState state, IBlockAccess world, BlockPos pos, EnumFacing side) {
    return false;
}
 

@Override
public int getFlammability(IBlockAccess world, BlockPos pos, EnumFacing face) {
    return 5;
}
 

@Override
public ArrayList<ItemStack> onSheared (ItemStack item, IBlockAccess world, int x, int y, int z, int fortune) {
    ArrayList<ItemStack> ret = new ArrayList<ItemStack>();
    ret.add(new ItemStack(this, 1));
    return ret;
}
 

public void setupXPosAOPartial (IBlockAccess blockAccess, Block block, int x, int y, int z, float r, float g, float b) {
    Tessellator tessellator = Tessellator.instance;
    tessellator.setBrightness(983055);

    int xGrass = (state.renderMaxX >= 1) ? x + 1 : x;

    boolean blocksGrassXYNP = !blockAccess.getBlock(xGrass, y + 1, z).getCanBlockGrass();
    boolean blocksGrassXYNN = !blockAccess.getBlock(xGrass, y - 1, z).getCanBlockGrass();
    boolean blocksGrassXZNN = !blockAccess.getBlock(xGrass, y, z - 1).getCanBlockGrass();
    boolean blocksGrassXZNP = !blockAccess.getBlock(xGrass, y, z + 1).getCanBlockGrass();

    if (state.renderMaxX < 1)
        setupAOBrightnessXPos(blockAccess, block, x, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP);

    setupAOBrightnessXNeg(blockAccess, block, x + 1, y, z, blocksGrassXYNP, blocksGrassXYNN, blocksGrassXZNN, blocksGrassXZNP);

    float xClamp = MathHelper.clamp_float((float) state.renderMaxX, 0, 1);
    mixAOBrightnessLightValueX(xClamp, 1 - xClamp);

    int blockBrightness = block.getMixedBrightnessForBlock(blockAccess, x, y, z);
    if (state.renderMaxX >= 1.0D || !blockAccess.getBlock(x + 1, y, z).isOpaqueCube())
        blockBrightness = block.getMixedBrightnessForBlock(blockAccess, x + 1, y, z);

    float aoOpposingBlock = blockAccess.getBlock(x + 1, y, z).getAmbientOcclusionLightValue();
    float aoXYZPNP = (aoLightValueScratchXYIN + aoLightValueScratchXYZINP + aoOpposingBlock + aoLightValueScratchXZIP) / 4.0F;
    float aoXYZPNN = (aoLightValueScratchXYZINN + aoLightValueScratchXYIN + aoLightValueScratchXZIN + aoOpposingBlock) / 4.0F;
    float aoXYZPPN = (aoLightValueScratchXZIN + aoOpposingBlock + aoLightValueScratchXYZIPN + aoLightValueScratchXYIP) / 4.0F;
    float aoXYZPPP = (aoOpposingBlock + aoLightValueScratchXZIP + aoLightValueScratchXYIP + aoLightValueScratchXYZIPP) / 4.0F;

    float aoTL = (float)((double)aoXYZPNP * (1.0D - state.renderMinY) * state.renderMaxZ + (double)aoXYZPNN * (1.0D - state.renderMinY) * (1.0D - state.renderMaxZ) + (double)aoXYZPPN * state.renderMinY * (1.0D - state.renderMaxZ) + (double)aoXYZPPP * state.renderMinY * state.renderMaxZ);
    float aoBL = (float)((double)aoXYZPNP * (1.0D - state.renderMinY) * state.renderMinZ + (double)aoXYZPNN * (1.0D - state.renderMinY) * (1.0D - state.renderMinZ) + (double)aoXYZPPN * state.renderMinY * (1.0D - state.renderMinZ) + (double)aoXYZPPP * state.renderMinY * state.renderMinZ);
    float aoBR = (float)((double)aoXYZPNP * (1.0D - state.renderMaxY) * state.renderMinZ + (double)aoXYZPNN * (1.0D - state.renderMaxY) * (1.0D - state.renderMinZ) + (double)aoXYZPPN * state.renderMaxY * (1.0D - state.renderMinZ) + (double)aoXYZPPP * state.renderMaxY * state.renderMinZ);
    float aoTR = (float)((double)aoXYZPNP * (1.0D - state.renderMaxY) * state.renderMaxZ + (double)aoXYZPNN * (1.0D - state.renderMaxY) * (1.0D - state.renderMaxZ) + (double)aoXYZPPN * state.renderMaxY * (1.0D - state.renderMaxZ) + (double)aoXYZPPP * state.renderMaxY * state.renderMaxZ);

    int brXYZPNP = getAOBrightness(aoBrightnessXYIN, aoBrightnessXYZINP, aoBrightnessXZIP, blockBrightness);
    int brXYZPNN = getAOBrightness(aoBrightnessXZIP, aoBrightnessXYIP, aoBrightnessXYZIPP, blockBrightness);
    int brXYZPPN = getAOBrightness(aoBrightnessXZIN, aoBrightnessXYZIPN, aoBrightnessXYIP, blockBrightness);
    int brXYZPPP = getAOBrightness(aoBrightnessXYZINN, aoBrightnessXYIN, aoBrightnessXZIN, blockBrightness);

    state.brightnessTopLeft = mixAOBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - state.renderMinY) * state.renderMaxZ, (1.0D - state.renderMinY) * (1.0D - state.renderMaxZ), state.renderMinY * (1.0D - state.renderMaxZ), state.renderMinY * state.renderMaxZ);
    state.brightnessBottomLeft = mixAOBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - state.renderMinY) * state.renderMinZ, (1.0D - state.renderMinY) * (1.0D - state.renderMinZ), state.renderMinY * (1.0D - state.renderMinZ), state.renderMinY * state.renderMinZ);
    state.brightnessBottomRight = mixAOBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - state.renderMaxY) * state.renderMinZ, (1.0D - state.renderMaxY) * (1.0D - state.renderMinZ), state.renderMaxY * (1.0D - state.renderMinZ), state.renderMaxY * state.renderMinZ);
    state.brightnessTopRight = mixAOBrightness(brXYZPNP, brXYZPPP, brXYZPPN, brXYZPNN, (1.0D - state.renderMaxY) * state.renderMaxZ, (1.0D - state.renderMaxY) * (1.0D - state.renderMaxZ), state.renderMaxY * (1.0D - state.renderMaxZ), state.renderMaxY * state.renderMaxZ);

    state.setColor(r * state.colorMultXPos, g * state.colorMultXPos, b * state.colorMultXPos);
    state.scaleColor(state.colorTopLeft, aoTL);
    state.scaleColor(state.colorBottomLeft, aoBL);
    state.scaleColor(state.colorBottomRight, aoBR);
    state.scaleColor(state.colorTopRight, aoTR);
}
 

@Override
public boolean canCreatureSpawn(IBlockState state, IBlockAccess world, BlockPos pos, SpawnPlacementType type) {
    return false;
}
 

@Override
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4){
    setBlockBounds(BBConstants.VACUUM_PUMP_MIN_POS, 0F, BBConstants.VACUUM_PUMP_MIN_POS, BBConstants.VACUUM_PUMP_MAX_POS, BBConstants.VACUUM_PUMP_MAX_POS_TOP, BBConstants.VACUUM_PUMP_MAX_POS);
}
 

@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon (IBlockAccess blockAccess, int x, int y, int z, int side) {
    boolean nTop = blockAccess.getBlock(x, y + 1, z) == this;
    boolean nLeft = false;
    boolean nRight = false;

    int meta = blockAccess.getBlockMetadata(x, y, z);
    switch (side) {
        case 2:
            nLeft = (meta & 8) != 0
                || (blockAccess.getBlock(x + 1, y, z) == this && (blockAccess.getBlockMetadata(x + 1, y, z) & 1) != 0)
                || (blockAccess.getBlock(x + 1, y, z + 1) == this && (blockAccess.getBlockMetadata(x + 1, y, z + 1) & 2) != 0);
            nRight = (meta & 2) != 0
                || (blockAccess.getBlock(x - 1, y, z) == this && (blockAccess.getBlockMetadata(x - 1, y, z) & 1) != 0)
                || (blockAccess.getBlock(x - 1, y, z + 1) == this && (blockAccess.getBlockMetadata(x - 1, y, z + 1) & 8) != 0);
            break;
        case 3:
            nLeft = (meta & 2) != 0
                || (blockAccess.getBlock(x - 1, y, z) == this && (blockAccess.getBlockMetadata(x - 1, y, z) & 4) != 0)
                || (blockAccess.getBlock(x - 1, y, z - 1) == this && (blockAccess.getBlockMetadata(x - 1, y, z - 1) & 8) != 0);
            nRight = (meta & 8) != 0
                || (blockAccess.getBlock(x + 1, y, z) == this && (blockAccess.getBlockMetadata(x + 1, y, z) & 4) != 0)
                || (blockAccess.getBlock(x + 1, y, z - 1) == this && (blockAccess.getBlockMetadata(x + 1, y, z - 1) & 2) != 0);
            break;
        case 4:
            nLeft = (meta & 4) != 0
                || (blockAccess.getBlock(x, y, z - 1) == this && (blockAccess.getBlockMetadata(x, y, z - 1) & 8) != 0)
                || (blockAccess.getBlock(x + 1, y, z - 1) == this && (blockAccess.getBlockMetadata(x + 1, y, z - 1) & 1) != 0);
            nRight = (meta & 1) != 0
                || (blockAccess.getBlock(x, y, z + 1) == this && (blockAccess.getBlockMetadata(x, y, z + 1) & 8) != 0)
                || (blockAccess.getBlock(x + 1, y, z + 1) == this && (blockAccess.getBlockMetadata(x + 1, y, z + 1) & 4) != 0);
            break;
        case 5:
            nLeft = (meta & 1) != 0
                || (blockAccess.getBlock(x, y, z + 1) == this && (blockAccess.getBlockMetadata(x, y, z + 1) & 2) != 0)
                || (blockAccess.getBlock(x - 1, y, z + 1) == this && (blockAccess.getBlockMetadata(x - 1, y, z + 1) & 4) != 0);
            nRight = (meta & 4) != 0
                || (blockAccess.getBlock(x, y, z - 1) == this && (blockAccess.getBlockMetadata(x, y, z - 1) & 2) != 0)
                || (blockAccess.getBlock(x - 1, y, z - 1) == this && (blockAccess.getBlockMetadata(x - 1, y, z - 1) & 1) != 0);
            break;
    }

    if (nTop) {
        if (nLeft && nRight)
            return textures[4];
        else if (nLeft)
            return textures[3];
        else if (nRight)
            return textures[2];
        else
            return textures[1];
    }
    else {
        if (nLeft && nRight)
            return textures[7];
        else if (nLeft)
            return textures[6];
        else if (nRight)
            return textures[5];
        else
            return textures[0];
    }
}
 

@Override
public int getFireSpreadSpeed(IBlockAccess world, BlockPos pos,
		EnumFacing face) {
	return 50;
}
 

@Override
public EnumPlantType getPlantType(IBlockAccess world, BlockPos pos) {
    return EnumPlantType.Plains;
}
 

@Override
public List<ItemStack> onSheared(ItemStack item, IBlockAccess world, BlockPos pos, int fortune) {
    return NonNullList.withSize(1, new ItemStack(this, 1));
}
 

@Override
public boolean canHack(IBlockAccess world, int x, int y, int z, EntityPlayer player){
    return true;
}
 

@Override
public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, Block b, int modelId, RenderBlocks renderer)
{
    int meta = world.getBlockMetadata(x, y, z);
    BlockRoadLine block = (BlockRoadLine) b;
    Tessellator tessellator = Tessellator.instance;

    tessellator.setBrightness(block.getMixedBrightnessForBlock(world, x, y, z));

    float f = 1.0F;
    int i1 = block.colorMultiplier(world, x, y, z);
    float f1 = (i1 >> 16 & 255) / 255.0F;
    float f2 = (i1 >> 8 & 255) / 255.0F;
    float f3 = (i1 & 255) / 255.0F;

    if(EntityRenderer.anaglyphEnable)
    {
        float f4 = (f1 * 30.0F + f2 * 59.0F + f3 * 11.0F) / 100.0F;
        float f5 = (f1 * 30.0F + f2 * 70.0F) / 100.0F;
        float f6 = (f1 * 30.0F + f3 * 70.0F) / 100.0F;
        f1 = f4;
        f2 = f5;
        f3 = f6;
    }
    tessellator.setColorOpaque_F(f * f1, f * f2, f * f3);

    boolean N = world.getBlock(x, y, z - 1).equals(block);
    boolean S = world.getBlock(x, y, z + 1).equals(block);
    boolean W = world.getBlock(x - 1, y, z).equals(block);
    boolean E = world.getBlock(x + 1, y, z).equals(block);

    if(!N && !S && !W && !E)
    {
        renderer.renderStandardBlock(block, x, y, z);
        return true;
    }

    if(N && S)
    {
        renderer.uvRotateTop = 0;
        renderer.overrideBlockTexture = block.fullLineIcon;
        renderer.renderStandardBlock(block, x, y, z);

    } else
    {
        if(N)
        {
            renderer.uvRotateTop = 0;
            renderer.overrideBlockTexture = block.halfLineIcon;
            renderer.renderStandardBlock(block, x, y, z);
        }
        if(S)
        {
            renderer.uvRotateTop = 3;
            renderer.overrideBlockTexture = block.halfLineIcon;
            renderer.renderStandardBlock(block, x, y, z);
        }

    }

    if(E && W)
    {
        renderer.uvRotateTop = 1;
        renderer.overrideBlockTexture = block.fullLineIcon;
        renderer.renderStandardBlock(block, x, y, z);
    } else
    {
        if(E)
        {
            renderer.uvRotateTop = 1;
            renderer.overrideBlockTexture = block.halfLineIcon;
            renderer.renderStandardBlock(block, x, y, z);
        }
        if(W)
        {
            renderer.uvRotateTop = 2;
            renderer.overrideBlockTexture = block.halfLineIcon;
            renderer.renderStandardBlock(block, x, y, z);
        }
    }

    renderer.uvRotateTop = 0;
    renderer.overrideBlockTexture = null;
    return true;
}
 

@Override
public int getFireSpreadSpeed(IBlockAccess world, BlockPos pos,
		EnumFacing face) {
	return 50;
}
 

public static Block getPlantBlock (IBlockAccess world, int x, int y, int z, ItemStack plant) {
    return getPlantBlock(world, x, y, z, getPlantable(plant));
}