Improve code readability in binnie.botany package

This commit is contained in:
kordum authored and mezz committed 2017-04-28 17:45:38 -07:00
1 parent e05bf8bb7b
commit b609d6688f
93 files changed
+3594 -3838

No files matched your search

@@ -1,114 +1,113 @@
//
// Decompiled by Procyon v0.5.30
//
package binnie.botany.ceramic;
import binnie.botany.Botany;
import binnie.botany.CreativeTabBotany;
import binnie.botany.genetics.EnumFlowerColor;
import binnie.botany.items.BotanyItems;
import binnie.core.BinnieCore;
import net.minecraft.util.MovingObjectPosition;
import binnie.botany.Botany;
import net.minecraft.client.renderer.texture.IIconRegister;
import binnie.core.block.BlockMetadata;
import binnie.core.block.IBlockMetadata;
import binnie.core.block.IMultipassBlock;
import binnie.core.block.MultipassBlockRenderer;
import binnie.core.block.TileEntityMetadata;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import binnie.botany.genetics.EnumFlowerColor;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import java.util.List;
import net.minecraftforge.common.util.ForgeDirection;
import binnie.core.block.TileEntityMetadata;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.entity.player.EntityPlayer;
import binnie.core.block.BlockMetadata;
import net.minecraft.item.ItemStack;
import java.util.ArrayList;
import net.minecraft.world.World;
import binnie.botany.CreativeTabBotany;
import net.minecraft.block.material.Material;
import binnie.core.block.IMultipassBlock;
import binnie.core.block.IBlockMetadata;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipassBlock
{
import java.util.ArrayList;
import java.util.List;
public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipassBlock {
public BlockCeramicBrick() {
super(Material.rock);
this.setHardness(1.0f);
this.setResistance(5.0f);
this.setBlockName("ceramicBrick");
this.setCreativeTab(CreativeTabBotany.instance);
setHardness(1.0f);
setResistance(5.0f);
setBlockName("ceramicBrick");
setCreativeTab(CreativeTabBotany.instance);
}
private static BlockType getType(final int meta) {
private static BlockType getType(int meta) {
return new BlockType(meta);
}
@Override
public ArrayList<ItemStack> getDrops(final World world, final int x, final int y, final int z, final int blockMeta, final int fortune) {
public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int blockMeta, int fortune) {
return BlockMetadata.getBlockDropped(this, world, x, y, z, blockMeta);
}
@Override
public boolean removedByPlayer(final World world, final EntityPlayer player, final int x, final int y, final int z) {
public boolean removedByPlayer(World world, EntityPlayer player, int x, int y, int z) {
return BlockMetadata.breakBlock(this, player, world, x, y, z);
}
@Override
public TileEntity createNewTileEntity(final World var1, final int i) {
public TileEntity createNewTileEntity(World var1, int i) {
return new TileEntityMetadata();
}
@Override
public boolean hasTileEntity(final int meta) {
public boolean hasTileEntity(int meta) {
return true;
}
@Override
public boolean onBlockEventReceived(final World par1World, final int par2, final int par3, final int par4, final int par5, final int par6) {
super.onBlockEventReceived(par1World, par2, par3, par4, par5, par6);
final TileEntity tileentity = par1World.getTileEntity(par2, par3, par4);
return tileentity != null && tileentity.receiveClientEvent(par5, par6);
public boolean onBlockEventReceived(World world, int x, int y, int z, int eventId, int eventType) {
super.onBlockEventReceived(world, x, y, z, eventId, eventType);
TileEntity tileentity = world.getTileEntity(x, y, z);
return tileentity != null && tileentity.receiveClientEvent(eventId, eventType);
}
@Override
public int getPlacedMeta(final ItemStack itemStack, final World world, final int x, final int y, final int z, final ForgeDirection direction) {
public int getPlacedMeta(ItemStack itemStack, World world, int x, int y, int z, ForgeDirection direction) {
return TileEntityMetadata.getItemDamage(itemStack);
}
@Override
public int getDroppedMeta(final int blockMeta, final int tileMeta) {
public int getDroppedMeta(int blockMeta, int tileMeta) {
return tileMeta;
}
@Override
public String getBlockName(final ItemStack itemStack) {
final int meta = TileEntityMetadata.getItemDamage(itemStack);
public String getBlockName(ItemStack itemStack) {
int meta = TileEntityMetadata.getItemDamage(itemStack);
return getType(meta).getName();
}
@Override
public void getBlockTooltip(final ItemStack itemStack, final List tooltip) {
public void getBlockTooltip(ItemStack itemStack, List tooltip) {
// ignored
}
@Override
public void dropAsStack(final World world, final int x, final int y, final int z, final ItemStack itemStack) {
this.dropBlockAsItem(world, x, y, z, itemStack);
public void dropAsStack(World world, int x, int y, int z, ItemStack itemStack) {
dropBlockAsItem(world, x, y, z, itemStack);
}
@Override
public void getSubBlocks(final Item par1, final CreativeTabs par2CreativeTabs, final List itemList) {
for (final EnumFlowerColor c : EnumFlowerColor.values()) {
final BlockType type = new BlockType(c, c, TileType.Tile);
public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List itemList) {
for (EnumFlowerColor c : EnumFlowerColor.values()) {
BlockType type = new BlockType(c, c, TileType.Tile);
itemList.add(TileEntityMetadata.getItemStack(this, type.ordinal()));
}
for (final TileType type2 : TileType.values()) {
for (TileType type2 : TileType.values()) {
if (type2.canDouble()) {
itemList.add(new BlockType(EnumFlowerColor.Brown, EnumFlowerColor.Gold, type2).getStack(1));
}
}
itemList.add(new BlockType(EnumFlowerColor.Gold, EnumFlowerColor.Gold, TileType.Split).getStack(1));
itemList.add(new BlockType(EnumFlowerColor.Brown, EnumFlowerColor.Brown, TileType.Chequered).getStack(1));
itemList.add(new BlockType(EnumFlowerColor.Gold, EnumFlowerColor.Brown, TileType.LargeBrick).getStack(1));
@@ -116,23 +115,23 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(final IBlockAccess world, final int x, final int y, final int z, final int side) {
final TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
if (tile != null) {
return this.getIcon(side, tile.getTileMetadata());
return getIcon(side, tile.getTileMetadata());
}
return super.getIcon(world, x, y, z, side);
}
@Override
public IIcon getIcon(final int side, final int meta) {
public IIcon getIcon(int side, int meta) {
return getType(meta).getIcon(MultipassBlockRenderer.getLayer());
}
@Override
@SideOnly(Side.CLIENT)
public void registerBlockIcons(final IIconRegister register) {
for (final TileType type : TileType.values()) {
public void registerBlockIcons(IIconRegister register) {
for (TileType type : TileType.values()) {
for (int i = 0; i < 3; ++i) {
type.icons[i] = Botany.proxy.getIcon(register, "ceramic." + type.id + "." + i);
}
@@ -141,29 +140,29 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
@Override
@SideOnly(Side.CLIENT)
public int colorMultiplier(final IBlockAccess world, final int x, final int y, final int z) {
final TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
public int colorMultiplier(IBlockAccess world, int x, int y, int z) {
TileEntityMetadata tile = TileEntityMetadata.getTile(world, x, y, z);
if (tile != null) {
return this.getRenderColor(tile.getTileMetadata());
return getRenderColor(tile.getTileMetadata());
}
return 16777215;
}
@Override
public void breakBlock(final World par1World, final int par2, final int par3, final int par4, final Block par5, final int par6) {
super.breakBlock(par1World, par2, par3, par4, par5, par6);
par1World.removeTileEntity(par2, par3, par4);
public void breakBlock(World world, int x, int y, int z, Block block, int side) {
super.breakBlock(world, x, y, z, block, side);
world.removeTileEntity(x, y, z);
}
@Override
public ItemStack getPickBlock(final MovingObjectPosition target, final World world, final int x, final int y, final int z) {
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
return BlockMetadata.getPickBlock(world, x, y, z);
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderColor(final int meta) {
return this.colorMultiplier(meta);
public int getRenderColor(int meta) {
return colorMultiplier(meta);
}
@Override
@@ -172,10 +171,10 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
}
@Override
public int colorMultiplier(final int meta) {
final BlockType type = getType(meta);
public int colorMultiplier(int meta) {
BlockType type = getType(meta);
if (MultipassBlockRenderer.getLayer() == 0) {
return 16777215;
return 0xffffff;
}
if (MultipassBlockRenderer.getLayer() == 1) {
return type.color1.getColor(false);
@@ -188,8 +187,7 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
return BinnieCore.multipassRenderID;
}
public enum TileType
{
public enum TileType {
Tile("tile", "Ceramic Tile"),
Brick("brick", "Ceramic Bricks"),
StripeBrick("brickstripe", "Striped Ceramic Bricks"),
@@ -201,17 +199,17 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
VerticalStripeBrick("verticalbrickstripe", "Vertical Striped Ceramic Bricks"),
VerticalLargeBrick("verticalbricklarge", "Large Vertical Ceramic Bricks");
String id;
String name;
IIcon[] icons;
protected String id;
protected String name;
protected IIcon[] icons;
private TileType(final String id, final String name) {
this.icons = new IIcon[3];
TileType(String id, String name) {
icons = new IIcon[3];
this.id = id;
this.name = name;
}
public static TileType get(final int id) {
public static TileType get(int id) {
return values()[id % values().length];
}
@@ -219,311 +217,330 @@ public class BlockCeramicBrick extends Block implements IBlockMetadata, IMultipa
return this != TileType.Tile;
}
public ItemStack getRecipe(final List<ItemStack> stacks) {
public ItemStack getRecipe(List<ItemStack> stacks) {
switch (this) {
case Tile: {
if (stacks.size() != 4) {
return null;
}
int mortars = 0;
int blocks = 0;
int blockColor = -1;
for (final ItemStack stack : stacks) {
if (this.isMortar(stack)) {
++mortars;
}
else {
if (stack.getItem() != Item.getItemFromBlock(Botany.ceramic)) {
return null;
}
++blocks;
final int color = TileEntityMetadata.getItemDamage(stack);
if (blockColor == -1) {
blockColor = color;
}
else {
if (blockColor != color) {
return null;
}
continue;
}
}
}
if (mortars != 1) {
return null;
}
final EnumFlowerColor c = EnumFlowerColor.get(blockColor);
return new BlockType(c, c, TileType.Tile).getStack(3);
}
case Split: {
if (stacks.size() != 4) {
return null;
}
final int[] colors = { -1, -1 };
int altCounter = 0;
for (final ItemStack stack2 : stacks) {
final int alt = (altCounter != 0 && altCounter != 3) ? 1 : 0;
if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
final BlockType type = new BlockType(stack2);
if (type.type != TileType.Tile) {
return null;
}
final int color2 = type.color1.ordinal();
if (colors[alt] == -1) {
colors[alt] = color2;
}
else if (colors[alt] != color2) {
return null;
}
++altCounter;
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Split).getStack(4);
}
case Chequered: {
if (stacks.size() != 4) {
return null;
}
final int[] colors = { -1, -1 };
for (final ItemStack stack2 : stacks) {
if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
final BlockType type2 = new BlockType(stack2);
if (type2.type != TileType.Split) {
return null;
}
final int color3 = type2.color1.ordinal();
final int color4 = type2.color2.ordinal();
if (colors[0] == -1) {
colors[0] = color3;
colors[1] = color4;
}
else {
if (colors[0] != color3 || colors[1] != color4) {
return null;
}
continue;
}
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Chequered).getStack(4);
}
case Mixed: {
if (stacks.size() != 4) {
return null;
}
final int[] colors = { -1, -1 };
for (int index = 0; index < stacks.size(); ++index) {
final ItemStack stack2 = stacks.get(index);
if (stack2.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
final BlockType type2 = new BlockType(stack2);
if (type2.isTwoColors()) {
return null;
}
final int color3 = type2.color1.ordinal();
if (type2.type == TileType.Split) {
if (colors[1] != -1) {
return null;
}
colors[1] = color3;
}
else {
if (type2.type != TileType.Chequered) {
return null;
}
if (colors[0] == -1) {
colors[0] = color3;
}
else if (colors[0] != color3) {
return null;
}
}
final int color4 = type2.color2.ordinal();
}
if (colors[0] == -1 || colors[1] == -1) {
return null;
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Mixed).getStack(4);
}
case LargeBrick: {
if (stacks.size() == 1) {
final ItemStack stack3 = stacks.get(0);
final BlockType type3 = new BlockType(stack3);
if (type3.type == TileType.VerticalLargeBrick) {
type3.type = this;
return type3.getStack(1);
}
return null;
}
else {
if (stacks.size() != 3) {
return null;
}
final int[] colors = { -1, -1 };
int a = 0;
int b = 0;
for (int index2 = 0; index2 < stacks.size(); ++index2) {
final ItemStack stack4 = stacks.get(index2);
if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
final BlockType type4 = new BlockType(stack4);
if (type4.type != TileType.Tile) {
return null;
}
final int color5 = type4.color1.ordinal();
if (colors[0] == -1) {
colors[0] = color5;
++a;
}
else if (colors[0] == color5) {
++a;
}
else if (colors[1] == -1) {
colors[1] = color5;
++b;
}
else {
if (colors[1] != color5) {
return null;
}
++b;
}
}
if (colors[1] == -1) {
colors[1] = colors[0];
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.LargeBrick).getStack(3);
}
}
case Brick:
case StripeBrick: {
if (stacks.size() == 1) {
final ItemStack stack5 = stacks.get(0);
final BlockType type = new BlockType(stack5);
if (type.type == TileType.VerticalBrick) {
type.type = this;
return type.getStack(1);
}
if (type.type == TileType.StripeBrick) {
type.type = this;
return type.getStack(1);
}
return null;
}
else {
if (stacks.size() != 4) {
return null;
}
final int[] colors = { -1, -1 };
for (int index2 = 0; index2 < stacks.size(); ++index2) {
final ItemStack stack4 = stacks.get(index2);
if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
final BlockType type4 = new BlockType(stack4);
if (type4.type != TileType.LargeBrick) {
return null;
}
final int color5 = type4.color1.ordinal();
final int color6 = type4.color2.ordinal();
int alt2 = (index2 != 0 && index2 != 3) ? 1 : 0;
if (this == TileType.StripeBrick) {
alt2 = 0;
}
if (colors[alt2] == -1) {
colors[alt2] = color5;
colors[1 - alt2] = color6;
}
else if (colors[alt2] != color5 || colors[1 - alt2] != color6) {
return null;
}
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), this).getStack(4);
}
}
case VerticalLargeBrick:
case VerticalBrick:
case VerticalStripeBrick: {
if (stacks.size() != 1) {
return null;
}
final ItemStack stack5 = stacks.get(0);
final BlockType type = new BlockType(stack5);
if (type.type == TileType.LargeBrick) {
type.type = TileType.VerticalLargeBrick;
return type.getStack(1);
}
if (type.type == TileType.Brick) {
type.type = TileType.VerticalBrick;
return type.getStack(1);
}
if (type.type == TileType.StripeBrick) {
type.type = TileType.VerticalStripeBrick;
return type.getStack(1);
}
return null;
}
default: {
return null;
}
case Tile:
return getTileRecipe(stacks);
case Split:
return getSplitRecipe(stacks);
case Chequered:
return getChequeredRecipe(stacks);
case Mixed:
return getMixedRecipe(stacks);
case LargeBrick:
return getLargeBrickRecipe(stacks);
case Brick:
case StripeBrick:
return getBrickRecipe(stacks);
case VerticalLargeBrick:
case VerticalBrick:
case VerticalStripeBrick:
return getVerticalBrickRecipe(stacks);
}
return null;
}
private boolean isMortar(final ItemStack stack) {
return stack.getItem() == Botany.misc && stack.getItemDamage() == BotanyItems.Mortar.ordinal();
private ItemStack getTileRecipe(List<ItemStack> stacks) {
if (stacks.size() != 4) {
return null;
}
int mortars = 0;
int blockColor = -1;
for (ItemStack stack : stacks) {
if (isMortar(stack)) {
mortars++;
} else {
if (stack.getItem() != Item.getItemFromBlock(Botany.ceramic)) {
return null;
}
int color = TileEntityMetadata.getItemDamage(stack);
if (blockColor == -1) {
blockColor = color;
} else if (blockColor != color) {
return null;
}
}
}
if (mortars != 1) {
return null;
}
EnumFlowerColor c = EnumFlowerColor.get(blockColor);
return new BlockType(c, c, TileType.Tile).getStack(3);
}
private ItemStack getSplitRecipe(List<ItemStack> stacks) {
if (stacks.size() != 4) {
return null;
}
int[] colors = {-1, -1};
int altCounter = 0;
for (ItemStack stack : stacks) {
int alt = (altCounter != 0 && altCounter != 3) ? 1 : 0;
if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
BlockType type = new BlockType(stack);
if (type.type != TileType.Tile) {
return null;
}
int color2 = type.color1.ordinal();
if (colors[alt] == -1) {
colors[alt] = color2;
} else if (colors[alt] != color2) {
return null;
}
altCounter++;
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Split).getStack(4);
}
private ItemStack getChequeredRecipe(List<ItemStack> stacks) {
if (stacks.size() != 4) {
return null;
}
int[] colors = {-1, -1};
for (ItemStack stack : stacks) {
if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
BlockType type2 = new BlockType(stack);
if (type2.type != TileType.Split) {
return null;
}
int color1 = type2.color1.ordinal();
int color2 = type2.color2.ordinal();
if (colors[0] == -1) {
colors[0] = color1;
colors[1] = color2;
} else if (colors[0] != color1 || colors[1] != color2) {
return null;
}
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Chequered).getStack(4);
}
private ItemStack getMixedRecipe(List<ItemStack> stacks) {
if (stacks.size() != 4) {
return null;
}
int[] colors = {-1, -1};
for (ItemStack stack : stacks) {
if (stack.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
BlockType type2 = new BlockType(stack);
if (type2.isTwoColors()) {
return null;
}
int color3 = type2.color1.ordinal();
if (type2.type == TileType.Split) {
if (colors[1] != -1) {
return null;
}
colors[1] = color3;
} else {
if (type2.type != TileType.Chequered) {
return null;
}
if (colors[0] == -1) {
colors[0] = color3;
} else if (colors[0] != color3) {
return null;
}
}
}
if (colors[0] == -1 || colors[1] == -1) {
return null;
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.Mixed).getStack(4);
}
private ItemStack getLargeBrickRecipe(List<ItemStack> stacks) {
if (stacks.size() == 1) {
ItemStack stack3 = stacks.get(0);
BlockType type3 = new BlockType(stack3);
if (type3.type == TileType.VerticalLargeBrick) {
type3.type = this;
return type3.getStack(1);
}
return null;
}
if (stacks.size() != 3) {
return null;
}
int[] colors = {-1, -1};
for (ItemStack stack4 : stacks) {
if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
BlockType type4 = new BlockType(stack4);
if (type4.type != TileType.Tile) {
return null;
}
int color5 = type4.color1.ordinal();
if (colors[0] == -1) {
colors[0] = color5;
} else if (colors[1] == -1) {
colors[1] = color5;
} else if (colors[1] != color5) {
return null;
}
}
if (colors[1] == -1) {
colors[1] = colors[0];
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), TileType.LargeBrick).getStack(3);
}
private ItemStack getBrickRecipe(List<ItemStack> stacks) {
if (stacks.size() == 1) {
ItemStack stack5 = stacks.get(0);
BlockType type = new BlockType(stack5);
if (type.type == TileType.VerticalBrick) {
type.type = this;
return type.getStack(1);
}
if (type.type == TileType.StripeBrick) {
type.type = this;
return type.getStack(1);
}
return null;
}
if (stacks.size() != 4) {
return null;
}
int[] colors = {-1, -1};
for (int index2 = 0; index2 < stacks.size(); ++index2) {
ItemStack stack4 = stacks.get(index2);
if (stack4.getItem() != Item.getItemFromBlock(Botany.ceramicBrick)) {
return null;
}
BlockType type4 = new BlockType(stack4);
if (type4.type != TileType.LargeBrick) {
return null;
}
int color5 = type4.color1.ordinal();
int color6 = type4.color2.ordinal();
int alt2 = (index2 != 0 && index2 != 3) ? 1 : 0;
if (this == TileType.StripeBrick) {
alt2 = 0;
}
if (colors[alt2] == -1) {
colors[alt2] = color5;
colors[1 - alt2] = color6;
} else if (colors[alt2] != color5 || colors[1 - alt2] != color6) {
return null;
}
}
return new BlockType(EnumFlowerColor.get(colors[0]), EnumFlowerColor.get(colors[1]), this).getStack(4);
}
private ItemStack getVerticalBrickRecipe(List<ItemStack> stacks) {
if (stacks.size() != 1) {
return null;
}
ItemStack stack5 = stacks.get(0);
BlockType type = new BlockType(stack5);
if (type.type == TileType.LargeBrick) {
type.type = TileType.VerticalLargeBrick;
return type.getStack(1);
}
if (type.type == TileType.Brick) {
type.type = TileType.VerticalBrick;
return type.getStack(1);
}
if (type.type == TileType.StripeBrick) {
type.type = TileType.VerticalStripeBrick;
return type.getStack(1);
}
return null;
}
private boolean isMortar(ItemStack stack) {
return stack.getItem() == Botany.misc
&& stack.getItemDamage() == BotanyItems.Mortar.ordinal();
}
}
public static class BlockType
{
EnumFlowerColor color1;
EnumFlowerColor color2;
TileType type;
public static class BlockType {
protected EnumFlowerColor color1;
protected EnumFlowerColor color2;
protected TileType type;
private BlockType(final EnumFlowerColor color1, final EnumFlowerColor color2, final TileType type) {
private BlockType(EnumFlowerColor color1, EnumFlowerColor color2, TileType type) {
this.color1 = color1;
this.color2 = color2;
this.type = type;
}
public boolean isTwoColors() {
return this.type.canDouble() && this.color2 != this.color1;
return type.canDouble() && color2 != color1;
}
public BlockType(final ItemStack stack) {
public BlockType(ItemStack stack) {
this(TileEntityMetadata.getItemDamage(stack));
}
public ItemStack getStack(final int i) {
final ItemStack s = TileEntityMetadata.getItemStack(Botany.ceramicBrick, this.ordinal());
s.stackSize = i;
return s;
public ItemStack getStack(int stackSize) {
ItemStack stack = TileEntityMetadata.getItemStack(Botany.ceramicBrick, ordinal());
stack.stackSize = stackSize;
return stack;
}
public BlockType(final int id) {
this.color1 = EnumFlowerColor.get(id & 0xFF);
this.color2 = EnumFlowerColor.get(id >> 8 & 0xFF);
this.type = TileType.get(id >> 16 & 0xFF);
public BlockType(int id) {
color1 = EnumFlowerColor.get(id & 0xFF);
color2 = EnumFlowerColor.get(id >> 8 & 0xFF);
type = TileType.get(id >> 16 & 0xFF);
}
public String getName() {
String name = this.color1.getName();
if (this.type.canDouble() && this.color2 != this.color1) {
name = name + " & " + this.color2.getName();
String name = color1.getName();
if (type.canDouble() && color2 != color1) {
name = name + " & " + color2.getName();
}
return name + " " + this.type.name;
return name + " " + type.name;
}
public int ordinal() {
return this.color1.ordinal() + this.color2.ordinal() * 256 + this.type.ordinal() * 256 * 256;
return color1.ordinal() + color2.ordinal() * 256 + type.ordinal() * 256 * 256;
}
public IIcon getIcon(final int layer) {
return this.type.icons[layer];
public IIcon getIcon(int layer) {
return type.icons[layer];
}
}
}