Jump to content
Search the Forums BEFORE making a new post.
Currently supported: All versions

[solved] changing leaf texture based on graphics level

Kakarotvg

By Kakarotvg
in Modder Support

 Share

Recommended Posts

Kakarotvg Creeper Killer

Kakarotvg

Posted
Posted

I was wondering how you would get a custom leaf block to change between an opaque texture, when using fast graphics and the normal semitransparent texture when using fancy.  I know minecraft does it, but I can't figure out how.

 

here is the leaf block class

package kakarotvg.omega.blocks;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import kakarotvg.omega.Reference;
import kakarotvg.omega.handlers.blocks.BlockHandler;

import net.minecraft.block.Block;
import net.minecraft.block.BlockLeavesBase;
import net.minecraft.block.material.Material;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Icon;
import net.minecraft.world.ColorizerFoliage;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.IShearable;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class TealLeaf extends BlockLeavesBase implements IShearable {
    public static final String[] VGLEAF_TYPES = new String[] { "tealleaf" };
    public static final String[][] field_94396_b = new String[][] { { Reference.MOD_ID + ":" + "tealleaf" }, { Reference.MOD_ID + ":" + "tealleafopaque" } };

    @SideOnly(Side.CLIENT)
    /** 1 for fast graphic. 0 for fancy graphics. used in iconArray. */
    private int iconType;
    private Icon[][] iconArray = new Icon[2][];
    int[] adjacentTreeBlocks;

    public TealLeaf(int par1, Material material) {
        super(par1, material, true);
        this.setTickRandomly(true);
        this.setCreativeTab(CreativeTabs.tabDecorations);

    }

    /**
     * Called on server worlds only when the block has been replaced by a different block ID, or the same block with a different metadata value, but before the new metadata value is set. Args: World, x, y, z, old block ID, old metadata
     */
    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6) {
        byte b0 = 1;
        int j1 = b0 + 1;

        if (par1World.checkChunksExist(par2 - j1, par3 - j1, par4 - j1, par2 + j1, par3 + j1, par4 + j1)) {
            for (int k1 = -b0; k1 <= b0; ++k1) {
                for (int l1 = -b0; l1 <= b0; ++l1) {
                    for (int i2 = -b0; i2 <= b0; ++i2) {
                        int j2 = par1World.getBlockId(par2 + k1, par3 + l1, par4 + i2);

                        if (Block.blocksList[j2] != null) {
                            Block.blocksList[j2].beginLeavesDecay(par1World, par2 + k1, par3 + l1, par4 + i2);
                        }
                    }
                }
            }
        }
    }

    /**
     * Ticks the block if it's been scheduled
     */
    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
        if (!par1World.isRemote) {
            int l = par1World.getBlockMetadata(par2, par3, par4);

            if ((l &  != 0 && (l & 4) == 0) {
                byte b0 = 4;
                int i1 = b0 + 1;
                byte b1 = 32;
                int j1 = b1 * b1;
                int k1 = b1 / 2;

                if (this.adjacentTreeBlocks == null) {
                    this.adjacentTreeBlocks = new int[b1 * b1 * b1];
                }

                int l1;

                if (par1World.checkChunksExist(par2 - i1, par3 - i1, par4 - i1, par2 + i1, par3 + i1, par4 + i1)) {
                    int i2;
                    int j2;
                    int k2;

                    for (l1 = -b0; l1 <= b0; ++l1) {
                        for (i2 = -b0; i2 <= b0; ++i2) {
                            for (j2 = -b0; j2 <= b0; ++j2) {
                                k2 = par1World.getBlockId(par2 + l1, par3 + i2, par4 + j2);

                                Block block = Block.blocksList[k2];

                                if (block != null && block.canSustainLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = 0;
                                }
                                else if (block != null && block.isLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -2;
                                }
                                else {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -1;
                                }
                            }
                        }
                    }

                    for (l1 = 1; l1 <= 4; ++l1) {
                        for (i2 = -b0; i2 <= b0; ++i2) {
                            for (j2 = -b0; j2 <= b0; ++j2) {
                                for (k2 = -b0; k2 <= b0; ++k2) {
                                    if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1] == l1 - 1) {
                                        if (this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] = l1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                l1 = this.adjacentTreeBlocks[k1 * j1 + k1 * b1 + k1];

                if (l1 >= 0) {
                    par1World.setBlockMetadataWithNotify(par2, par3, par4, l & -9, 4);
                }
                else {
                    this.removeLeaves(par1World, par2, par3, par4);
                }
            }
        }
    }

    @SideOnly(Side.CLIENT)
    /**
     * A randomly called display update to be able to add particles or other items for display
     */
    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {
        if (par1World.canLightningStrikeAt(par2, par3 + 1, par4) && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && par5Random.nextInt(15) == 1) {
            double d0 = (double) ((float) par2 + par5Random.nextFloat());
            double d1 = (double) par3 - 0.05D;
            double d2 = (double) ((float) par4 + par5Random.nextFloat());
            par1World.spawnParticle("dripWater", d0, d1, d2, 0.0D, 0.0D, 0.0D);
        }
    }

    private void removeLeaves(World par1World, int par2, int par3, int par4) {
        this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
        par1World.setBlockToAir(par2, par3, par4);
    }

    /**
     * Returns the quantity of items to drop on block destruction.
     */
    public int quantityDropped(Random par1Random) {
        return par1Random.nextInt(20) == 0 ? 1 : 0;
    }

    /**
     * Returns the ID of the items to drop on destruction.
     */
    public int idDropped(int par1, Random par2Random, int par3) {
        return BlockHandler.tealsapling.blockID;
    }

    /**
     * Drops the block items with a specified chance of dropping the specified items
     */
    public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7) {
        if (!par1World.isRemote) {
            int j1 = 20;

            if ((par5 & 3) == 3) {
                j1 = 40;
            }

            if (par7 > 0) {
                j1 -= 2 << par7;

                if (j1 < 10) {
                    j1 = 10;
                }
            }

            if (par1World.rand.nextInt(j1) == 0) {
                int k1 = this.idDropped(par5, par1World.rand, par7);
                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(k1, 1, this.damageDropped(par5)));
            }

            j1 = 200;

            if (par7 > 0) {
                j1 -= 10 << par7;

                if (j1 < 40) {
                    j1 = 40;
                }
            }

            if ((par5 & 3) == 0 && par1World.rand.nextInt(j1) == 0) {
                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0));
            }
        }
    }

    /**
     * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the block and l is the block's subtype/damage.
     */
    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
        super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
    }

    public int damageDropped(int par1) {
        return par1 & 3;
    }

    /**
     * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
     */
    public boolean isOpaqueCube() {
        return !this.graphicsLevel;
    }

    public Icon getIcon(int par1, int par2) {
        return this.iconArray[this.iconType][0];
    }

    @SideOnly(Side.CLIENT)
    /**
     * Pass true to draw this block using fancy graphics, or false for fast graphics.
     */
    public void setGraphicsLevel(boolean par1) {
        this.graphicsLevel = par1;

        this.iconType = par1 ? 0 : 1;
    }

    @SideOnly(Side.CLIENT)
    /**
     * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
     */
    public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) {
        par3List.add(new ItemStack(par1, 1, 0));
    }

    /**
     * Returns an item stack containing a single instance of the current block type. 'i' is the block's subtype/damage and is ignored for blocks which do not support subtypes. Blocks which cannot be harvested should return null.
     */
    protected ItemStack createStackedBlock(int par1) {
        return new ItemStack(this.blockID, 1, par1 & 3);
    }

    @SideOnly(Side.CLIENT)
    /**
     * When this method is called, your block should register all the icons it needs with the given IconRegister. This
     * is the only chance you get to register icons.
     */
    public void registerIcons(IconRegister register) {

        for (int i = 0; i < field_94396_b.length; ++i) {
            this.iconArray[i] = new Icon[field_94396_b[i].length];

            for (int j = 0; j < field_94396_b[i].length; ++j) {
                this.iconArray[i][j] = register.registerIcon(field_94396_b[i][j]);
            }

        }

    }

    @Override
    public boolean isShearable(ItemStack item, World world, int x, int y, int z) {
        return true;
    }

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

    @Override
    public void beginLeavesDecay(World world, int x, int y, int z) {
        world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) | 8, 4);
    }

    @Override
    public boolean isLeaves(World world, int x, int y, int z) {
        return true;
    }
}



if (You.likescoding == false){
      You.goaway;
}

Draco18s Reality Controller

Draco18s

Posted
Posted

I looked into this once.  I don't recall if I ever found a solution.

I'll dig up my old code and see if it worked, and if so, I'll post it.

Apparently I'm a complete and utter jerk and come to this forum just like to make fun of people, be confrontational, and make your personal life miserable.  If you think this is the case, JUST REPORT ME.  Otherwise you're just going to get reported when you reply to my posts and point it out, because odds are, I was trying to be nice.

 

Exception: If you do not understand Java, I WILL NOT HELP YOU and your thread will get locked.

 

DO NOT PM ME WITH PROBLEMS. No help will be given.

Kakarotvg Creeper Killer

Kakarotvg

Posted
  • Author
Posted

thanks, the normal minecraft code is wierd, it returns false in the super constructor, yet when I do that with my block, it renders all weird.

if (You.likescoding == false){
      You.goaway;
}

TheGreyGhost Reality Controller

TheGreyGhost

Posted
Posted

Hi

 

What are the symptoms of the problem?  Have you tried putting a breakpoint in getIcon and seeing if the correct icon is being returned when you change the fancy graphics?

As far as I can tell, overriding getIcon should work fine.  You could perhaps simplify the code a bit by registering the two Icons without using arrays, but it should still work ok.

 

NB you should probably also override BlockLeavesBase.shouldSideBeRendered() to correctly handle internal faces between leaf blocks (see vanilla code).  I also notice you haven't put @Override in front of the methods you are overriding?  (Not essential, but can help pick up subtle problems).

 

If you list the symptoms in a bit more detail, we might be able to help more?

 

-TGG

 

 

Kakarotvg Creeper Killer

Kakarotvg

Posted
  • Author
Posted

Here is the new code with the @Override annotations

 

 

package kakarotvg.omega.blocks;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import kakarotvg.omega.Reference;
import kakarotvg.omega.handlers.blocks.BlockHandler;

import net.minecraft.block.Block;
import net.minecraft.block.BlockLeavesBase;
import net.minecraft.block.material.Material;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Icon;
import net.minecraft.world.ColorizerFoliage;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.IShearable;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

public class TealLeaf extends BlockLeavesBase implements IShearable {
    public static final String[] VGLEAF_TYPES = new String[] { "tealleaf" };
    public static final String[][] field_94396_b = new String[][] { { Reference.MOD_ID + ":" + "tealleaf" }, { Reference.MOD_ID + ":" + "tealleafopaque" } };

    @SideOnly(Side.CLIENT)
    /** 1 for fast graphic. 0 for fancy graphics. used in iconArray. */
    private int iconType;
    private Icon[][] iconArray = new Icon[2][];
    int[] adjacentTreeBlocks;

    public TealLeaf(int par1, Material material) {
        super(par1, material, false);
        this.setTickRandomly(true);
        this.setCreativeTab(CreativeTabs.tabDecorations);

    }

    /**
     * Called on server worlds only when the block has been replaced by a different block ID, or the same block with a different metadata value, but before the new metadata value is set. Args: World, x, y, z, old block ID, old metadata
     */
    @Override
    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6) {
        byte b0 = 1;
        int j1 = b0 + 1;

        if (par1World.checkChunksExist(par2 - j1, par3 - j1, par4 - j1, par2 + j1, par3 + j1, par4 + j1)) {
            for (int k1 = -b0; k1 <= b0; ++k1) {
                for (int l1 = -b0; l1 <= b0; ++l1) {
                    for (int i2 = -b0; i2 <= b0; ++i2) {
                        int j2 = par1World.getBlockId(par2 + k1, par3 + l1, par4 + i2);

                        if (Block.blocksList[j2] != null) {
                            Block.blocksList[j2].beginLeavesDecay(par1World, par2 + k1, par3 + l1, par4 + i2);
                        }
                    }
                }
            }
        }
    }

    /**
     * Ticks the block if it's been scheduled
     */
    @Override
    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
        if (!par1World.isRemote) {
            int l = par1World.getBlockMetadata(par2, par3, par4);

            if ((l &  != 0 && (l & 4) == 0) {
                byte b0 = 4;
                int i1 = b0 + 1;
                byte b1 = 32;
                int j1 = b1 * b1;
                int k1 = b1 / 2;

                if (this.adjacentTreeBlocks == null) {
                    this.adjacentTreeBlocks = new int[b1 * b1 * b1];
                }

                int l1;

                if (par1World.checkChunksExist(par2 - i1, par3 - i1, par4 - i1, par2 + i1, par3 + i1, par4 + i1)) {
                    int i2;
                    int j2;
                    int k2;

                    for (l1 = -b0; l1 <= b0; ++l1) {
                        for (i2 = -b0; i2 <= b0; ++i2) {
                            for (j2 = -b0; j2 <= b0; ++j2) {
                                k2 = par1World.getBlockId(par2 + l1, par3 + i2, par4 + j2);

                                Block block = Block.blocksList[k2];

                                if (block != null && block.canSustainLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = 0;
                                }
                                else if (block != null && block.isLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -2;
                                }
                                else {
                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -1;
                                }
                            }
                        }
                    }

                    for (l1 = 1; l1 <= 4; ++l1) {
                        for (i2 = -b0; i2 <= b0; ++i2) {
                            for (j2 = -b0; j2 <= b0; ++j2) {
                                for (k2 = -b0; k2 <= b0; ++k2) {
                                    if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1] == l1 - 1) {
                                        if (this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] = l1;
                                        }

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] == -2) {
                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] = l1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

                l1 = this.adjacentTreeBlocks[k1 * j1 + k1 * b1 + k1];

                if (l1 >= 0) {
                    par1World.setBlockMetadataWithNotify(par2, par3, par4, l & -9, 4);
                }
                else {
                    this.removeLeaves(par1World, par2, par3, par4);
                }
            }
        }
    }

    @SideOnly(Side.CLIENT)
    /**
     * A randomly called display update to be able to add particles or other items for display
     */
    @Override
    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {
        if (par1World.canLightningStrikeAt(par2, par3 + 1, par4) && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && par5Random.nextInt(15) == 1) {
            double d0 = (double) ((float) par2 + par5Random.nextFloat());
            double d1 = (double) par3 - 0.05D;
            double d2 = (double) ((float) par4 + par5Random.nextFloat());
            par1World.spawnParticle("dripWater", d0, d1, d2, 0.0D, 0.0D, 0.0D);
        }
    }

    private void removeLeaves(World par1World, int par2, int par3, int par4) {
        this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);
        par1World.setBlockToAir(par2, par3, par4);
    }

    /**
     * Returns the quantity of items to drop on block destruction.
     */
    @Override
    public int quantityDropped(Random par1Random) {
        return par1Random.nextInt(20) == 0 ? 1 : 0;
    }

    /**
     * Returns the ID of the items to drop on destruction.
     */
    @Override
    public int idDropped(int par1, Random par2Random, int par3) {
        return BlockHandler.tealsapling.blockID;
    }

    /**
     * Drops the block items with a specified chance of dropping the specified items
     */
    @Override
    public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7) {
        if (!par1World.isRemote) {
            int j1 = 20;

            if ((par5 & 3) == 3) {
                j1 = 40;
            }

            if (par7 > 0) {
                j1 -= 2 << par7;

                if (j1 < 10) {
                    j1 = 10;
                }
            }

            if (par1World.rand.nextInt(j1) == 0) {
                int k1 = this.idDropped(par5, par1World.rand, par7);
                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(k1, 1, this.damageDropped(par5)));
            }

            j1 = 200;

            if (par7 > 0) {
                j1 -= 10 << par7;

                if (j1 < 40) {
                    j1 = 40;
                }
            }

            if ((par5 & 3) == 0 && par1World.rand.nextInt(j1) == 0) {
                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0));
            }
        }
    }

    /**
     * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the block and l is the block's subtype/damage.
     */
    @Override
    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
        super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
    }

    @Override
    public int damageDropped(int par1) {
        return par1 & 3;
    }

    /**
     * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
     */
    @Override
    public boolean isOpaqueCube() {
        return !this.graphicsLevel;
    }

    @Override
    public Icon getIcon(int par1, int par2) {
        return this.iconArray[this.iconType][0];
    }

    @SideOnly(Side.CLIENT)
    /**
     * Pass true to draw this block using fancy graphics, or false for fast graphics.
     */
    public void setGraphicsLevel(boolean par1) {
        this.graphicsLevel = par1;

        this.iconType = par1 ? 0 : 1;
    }

    @Override
    public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
        int i1 = par1IBlockAccess.getBlockId(par2, par3, par4);
        return !this.graphicsLevel && i1 == this.blockID ? false : super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5);
    }

    @SideOnly(Side.CLIENT)
    @Override
    /**
     * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)
     */
    public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) {
        par3List.add(new ItemStack(par1, 1, 0));
    }

    /**
     * Returns an item stack containing a single instance of the current block type. 'i' is the block's subtype/damage and is ignored for blocks which do not support subtypes. Blocks which cannot be harvested should return null.
     */
    @Override
    protected ItemStack createStackedBlock(int par1) {
        return new ItemStack(this.blockID, 1, par1 & 3);
    }

    @SideOnly(Side.CLIENT)
    /**
     * When this method is called, your block should register all the icons it needs with the given IconRegister. This
     * is the only chance you get to register icons.
     */
    @Override
    public void registerIcons(IconRegister register) {

        for (int i = 0; i < field_94396_b.length; ++i) {
            this.iconArray[i] = new Icon[field_94396_b[i].length];

            for (int j = 0; j < field_94396_b[i].length; ++j) {
                this.iconArray[i][j] = register.registerIcon(field_94396_b[i][j]);
            }

        }

    }

    @Override
    public boolean isShearable(ItemStack item, World world, int x, int y, int z) {
        return true;
    }

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

    @Override
    public void beginLeavesDecay(World world, int x, int y, int z) {
        world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) | 8, 4);
    }

    @Override
    public boolean isLeaves(World world, int x, int y, int z) {
        return true;
    }
}

 

 

 

images of whats happening

 

 

when returning true in super constructor

 

fancy

hU6zTUo.png

 

fast

TyG5DZ2.png

 

when returning false in super construct

 

fancy/fast

1qFgOzM.png

 

 

if (You.likescoding == false){
      You.goaway;
}

Mazetar World Shaper

Mazetar

Posted
Posted 

/**
     * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.
     */
    @Override
    public boolean isOpaqueCube() {
        return !this.graphicsLevel;
    }

 

This should always return false as the block can always be seen through

If you guys dont get it.. then well ya.. try harder...

Kakarotvg Creeper Killer

Kakarotvg

Posted
  • Author
Posted

the issue with being see through is gone, but I still can't get it to switch the texture whenever minecraft is on fancy or fast graphics

if (You.likescoding == false){
      You.goaway;
}

TheGreyGhost Reality Controller

TheGreyGhost

Posted
Posted

Odd.

 

Are you sure your textures are right?  And that your getIcon is actually being called?

 

Perhaps you could try swapping the texture names in your code and seeing if it changes to opaque.

ie change to

public static final String[][] field_94396_b = new String[][] { { Reference.MOD_ID + ":" + "tealleafopaque" }, { Reference.MOD_ID + ":" + "tealleaf" } }

 

You might also be better off to simplify your Icon selection since you don't need arrays - might be easier to debug; eg

 

private Icon opaqueLeaves;

private Icon transparentLeaves;

 

@Override

public Icon getIcon(int par1, int par2) {

  if (iconType == 0) return opaqueLeaves;

  return transparentLeaves;     

}

@Override

    public void registerIcons(IconRegister register) {

        opaqueLeaves = register.registerIcon(Reference.MOD_ID + ":" + "tealleafopaque");

        transparentLeaves = register.registerIcon(Reference.MOD_ID + ":" + "tealleaf");

            }

 

        }

 

    }

 

Otherwise, I'm out of ideas...

 

-TGG

 

 

 

 

Kakarotvg Creeper Killer

Kakarotvg

Posted
  • Author
Posted

I did what you said and there was one thing causing it to not work,

 

but this got it to work

@Override
    public Icon getIcon(int par1, int par2) {
        if (Minecraft.isFancyGraphicsEnabled() == false) {
            return opaqueleaves;
        }

        return transparentleaves;
    }

 

full class

 

 

package kakarotvg.omega.blocks;

 

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

 

import kakarotvg.omega.Reference;

import kakarotvg.omega.handlers.blocks.BlockHandler;

 

import net.minecraft.block.Block;

import net.minecraft.block.BlockLeavesBase;

import net.minecraft.block.material.Material;

import net.minecraft.client.Minecraft;

import net.minecraft.client.renderer.texture.IconRegister;

import net.minecraft.creativetab.CreativeTabs;

import net.minecraft.entity.player.EntityPlayer;

import net.minecraft.item.Item;

import net.minecraft.item.ItemStack;

import net.minecraft.util.Icon;

import net.minecraft.world.ColorizerFoliage;

import net.minecraft.world.IBlockAccess;

import net.minecraft.world.World;

import net.minecraftforge.common.IShearable;

import cpw.mods.fml.relauncher.Side;

import cpw.mods.fml.relauncher.SideOnly;

 

public class TealLeaf extends BlockLeavesBase implements IShearable {

 

    @SideOnly(Side.CLIENT)

    /** 1 for fast graphic. 0 for fancy graphics. used in iconArray. */

    int[] adjacentTreeBlocks;

 

    @SideOnly(Side.CLIENT)

    private Icon opaqueleaves;

    private Icon transparentleaves;

 

    public TealLeaf(int par1, Material material) {

        super(par1, material, true);

        this.setTickRandomly(true);

        this.setCreativeTab(CreativeTabs.tabDecorations);

 

    }

 

    /**

    * Called on server worlds only when the block has been replaced by a different block ID, or the same block with a different metadata value, but before the new metadata value is set. Args: World, x, y, z, old block ID, old metadata

    */

    @Override

    public void breakBlock(World par1World, int par2, int par3, int par4, int par5, int par6) {

        byte b0 = 1;

        int j1 = b0 + 1;

 

        if (par1World.checkChunksExist(par2 - j1, par3 - j1, par4 - j1, par2 + j1, par3 + j1, par4 + j1)) {

            for (int k1 = -b0; k1 <= b0; ++k1) {

                for (int l1 = -b0; l1 <= b0; ++l1) {

                    for (int i2 = -b0; i2 <= b0; ++i2) {

                        int j2 = par1World.getBlockId(par2 + k1, par3 + l1, par4 + i2);

 

                        if (Block.blocksList[j2] != null) {

                            Block.blocksList[j2].beginLeavesDecay(par1World, par2 + k1, par3 + l1, par4 + i2);

                        }

                    }

                }

            }

        }

    }

 

    /**

    * Ticks the block if it's been scheduled

    */

    @Override

    public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {

        if (!par1World.isRemote) {

            int l = par1World.getBlockMetadata(par2, par3, par4);

 

            if ((l & 8) != 0 && (l & 4) == 0) {

                byte b0 = 4;

                int i1 = b0 + 1;

                byte b1 = 32;

                int j1 = b1 * b1;

                int k1 = b1 / 2;

 

                if (this.adjacentTreeBlocks == null) {

                    this.adjacentTreeBlocks = new int[b1 * b1 * b1];

                }

 

                int l1;

 

                if (par1World.checkChunksExist(par2 - i1, par3 - i1, par4 - i1, par2 + i1, par3 + i1, par4 + i1)) {

                    int i2;

                    int j2;

                    int k2;

 

                    for (l1 = -b0; l1 <= b0; ++l1) {

                        for (i2 = -b0; i2 <= b0; ++i2) {

                            for (j2 = -b0; j2 <= b0; ++j2) {

                                k2 = par1World.getBlockId(par2 + l1, par3 + i2, par4 + j2);

 

                                Block block = Block.blocksList[k2];

 

                                if (block != null && block.canSustainLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {

                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = 0;

                                }

                                else if (block != null && block.isLeaves(par1World, par2 + l1, par3 + i2, par4 + j2)) {

                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -2;

                                }

                                else {

                                    this.adjacentTreeBlocks[(l1 + k1) * j1 + (i2 + k1) * b1 + j2 + k1] = -1;

                                }

                            }

                        }

                    }

 

                    for (l1 = 1; l1 <= 4; ++l1) {

                        for (i2 = -b0; i2 <= b0; ++i2) {

                            for (j2 = -b0; j2 <= b0; ++j2) {

                                for (k2 = -b0; k2 <= b0; ++k2) {

                                    if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1] == l1 - 1) {

                                        if (this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1 - 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;

                                        }

 

                                        if (this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1 + 1) * j1 + (j2 + k1) * b1 + k2 + k1] = l1;

                                        }

 

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 - 1) * b1 + k2 + k1] = l1;

                                        }

 

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1 + 1) * b1 + k2 + k1] = l1;

                                        }

 

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + (k2 + k1 - 1)] = l1;

                                        }

 

                                        if (this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] == -2) {

                                            this.adjacentTreeBlocks[(i2 + k1) * j1 + (j2 + k1) * b1 + k2 + k1 + 1] = l1;

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

 

                l1 = this.adjacentTreeBlocks[k1 * j1 + k1 * b1 + k1];

 

                if (l1 >= 0) {

                    par1World.setBlockMetadataWithNotify(par2, par3, par4, l & -9, 4);

                }

                else {

                    this.removeLeaves(par1World, par2, par3, par4);

                }

            }

        }

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * A randomly called display update to be able to add particles or other items for display

    */

    @Override

    public void randomDisplayTick(World par1World, int par2, int par3, int par4, Random par5Random) {

        if (par1World.canLightningStrikeAt(par2, par3 + 1, par4) && !par1World.doesBlockHaveSolidTopSurface(par2, par3 - 1, par4) && par5Random.nextInt(15) == 1) {

            double d0 = (double) ((float) par2 + par5Random.nextFloat());

            double d1 = (double) par3 - 0.05D;

            double d2 = (double) ((float) par4 + par5Random.nextFloat());

            par1World.spawnParticle("dripWater", d0, d1, d2, 0.0D, 0.0D, 0.0D);

        }

    }

 

    private void removeLeaves(World par1World, int par2, int par3, int par4) {

        this.dropBlockAsItem(par1World, par2, par3, par4, par1World.getBlockMetadata(par2, par3, par4), 0);

        par1World.setBlockToAir(par2, par3, par4);

    }

 

    /**

    * Returns the quantity of items to drop on block destruction.

    */

    @Override

    public int quantityDropped(Random par1Random) {

        return par1Random.nextInt(20) == 0 ? 1 : 0;

    }

 

    /**

    * Returns the ID of the items to drop on destruction.

    */

    @Override

    public int idDropped(int par1, Random par2Random, int par3) {

        return BlockHandler.tealsapling.blockID;

    }

 

    /**

    * Drops the block items with a specified chance of dropping the specified items

    */

    @Override

    public void dropBlockAsItemWithChance(World par1World, int par2, int par3, int par4, int par5, float par6, int par7) {

        if (!par1World.isRemote) {

            int j1 = 20;

 

            if ((par5 & 3) == 3) {

                j1 = 40;

            }

 

            if (par7 > 0) {

                j1 -= 2 << par7;

 

                if (j1 < 10) {

                    j1 = 10;

                }

            }

 

            if (par1World.rand.nextInt(j1) == 0) {

                int k1 = this.idDropped(par5, par1World.rand, par7);

                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(k1, 1, this.damageDropped(par5)));

            }

 

            j1 = 200;

 

            if (par7 > 0) {

                j1 -= 10 << par7;

 

                if (j1 < 40) {

                    j1 = 40;

                }

            }

 

            if ((par5 & 3) == 0 && par1World.rand.nextInt(j1) == 0) {

                this.dropBlockAsItem_do(par1World, par2, par3, par4, new ItemStack(Item.appleRed, 1, 0));

            }

        }

    }

 

    /**

    * Called when the player destroys a block with an item that can harvest it. (i, j, k) are the coordinates of the block and l is the block's subtype/damage.

    */

    @Override

    public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {

        super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);

    }

 

    @Override

    public int damageDropped(int par1) {

        return par1 & 3;

    }

 

    /**

    * Is this block (a) opaque and (b) a full 1m cube? This determines whether or not to render the shared face of two adjacent blocks and also whether the player can attach torches, redstone wire, etc to this block.

    */

    @Override

    public boolean isOpaqueCube() {

        return false;

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * Pass true to draw this block using fancy graphics, or false for fast graphics.

    */

    @Override

    public Icon getIcon(int par1, int par2) {

        if (Minecraft.isFancyGraphicsEnabled() == false) {

            return opaqueleaves;

        }

 

        return transparentleaves;

    }

 

    @Override

    public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {

        int i1 = par1IBlockAccess.getBlockId(par2, par3, par4);

        return !this.graphicsLevel && i1 == this.blockID ? false : super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5);

    }

 

    @SideOnly(Side.CLIENT)

    @Override

    /**

    * returns a list of blocks with the same ID, but different meta (eg: wood returns 4 blocks)

    */

    public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List) {

        par3List.add(new ItemStack(par1, 1, 0));

    }

 

    /**

    * Returns an item stack containing a single instance of the current block type. 'i' is the block's subtype/damage and is ignored for blocks which do not support subtypes. Blocks which cannot be harvested should return null.

    */

    @Override

    protected ItemStack createStackedBlock(int par1) {

        return new ItemStack(this.blockID, 1, par1 & 3);

    }

 

    @SideOnly(Side.CLIENT)

    /**

    * When this method is called, your block should register all the icons it needs with the given IconRegister. This

    * is the only chance you get to register icons.

    */

    @Override

    public void registerIcons(IconRegister register) {

        opaqueleaves = register.registerIcon(Reference.MOD_ID + ":" + "tealleafopaque");

        transparentleaves = register.registerIcon(Reference.MOD_ID + ":" + "tealleaf");

    }

 

    @Override

    public boolean isShearable(ItemStack item, World world, int x, int y, int z) {

        return true;

    }

 

    @Override

    public ArrayList<ItemStack> onSheared(ItemStack item, World world, int x, int y, int z, int fortune) {

        ArrayList<ItemStack> ret = new ArrayList<ItemStack>();

        ret.add(new ItemStack(this, 1, world.getBlockMetadata(x, y, z) & 3));

        return ret;

    }

 

    @Override

    public void beginLeavesDecay(World world, int x, int y, int z) {

        world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x, y, z) | 8, 4);

    }

 

    @Override

    public boolean isLeaves(World world, int x, int y, int z) {

        return true;

    }

}

 

 

 

if (You.likescoding == false){
      You.goaway;
}

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Unfortunately, your content contains terms that we do not allow. Please edit your content to remove the highlighted words below.
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

×
 Share
Go to topic listing

Announcements



×
×
  • Create New...

Important Information

By using this site, you agree to our Terms of Use.

  I accept