diff options
Diffstat (limited to 'src/main/java/gregtech/api/objects')
14 files changed, 1121 insertions, 0 deletions
diff --git a/src/main/java/gregtech/api/objects/ElementStack.java b/src/main/java/gregtech/api/objects/ElementStack.java new file mode 100644 index 0000000000..f3e1543614 --- /dev/null +++ b/src/main/java/gregtech/api/objects/ElementStack.java @@ -0,0 +1,42 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Element; + +public class ElementStack implements Cloneable { + public int mAmount; + public Element mElement; + + public ElementStack(Element aElement, int aAmount) { + mElement = aElement == null ? Element._NULL : aElement; + mAmount = aAmount; + } + + public ElementStack copy(int aAmount) { + return new ElementStack(mElement, aAmount); + } + + @Override + public ElementStack clone() { + return new ElementStack(mElement, mAmount); + } + + @Override + public boolean equals(Object aObject) { + if (aObject == this) return true; + if (aObject == null) return false; + if (aObject instanceof Element) return aObject == mElement; + if (aObject instanceof ElementStack) + return ((ElementStack) aObject).mElement == mElement && (mAmount < 0 || ((ElementStack) aObject).mAmount < 0 || ((ElementStack) aObject).mAmount == mAmount); + return false; + } + + @Override + public String toString() { + return mElement.toString() + mAmount; + } + + @Override + public int hashCode() { + return mElement.hashCode(); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_ArrayList.java b/src/main/java/gregtech/api/objects/GT_ArrayList.java new file mode 100644 index 0000000000..5bc781e281 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_ArrayList.java @@ -0,0 +1,59 @@ +package gregtech.api.objects; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; + +public class GT_ArrayList<E> extends ArrayList<E> { + private static final long serialVersionUID = 1L; + + private final boolean mAllowNulls; + + public GT_ArrayList(boolean aAllowNulls, int aCapacity) { + super(aCapacity); + mAllowNulls = aAllowNulls; + } + + public GT_ArrayList(boolean aAllowNulls, E... aArray) { + super(Arrays.asList(aArray)); + mAllowNulls = aAllowNulls; + if (!mAllowNulls) for (int i = 0; i < size(); i++) if (get(i) == null) remove(i--); + } + + public GT_ArrayList(boolean aAllowNulls, Collection<? extends E> aList) { + super(aList); + mAllowNulls = aAllowNulls; + if (!mAllowNulls) for (int i = 0; i < size(); i++) if (get(i) == null) remove(i--); + } + + @Override + public E set(int aIndex, E aElement) { + if (mAllowNulls || aElement != null) return super.set(aIndex, aElement); + return null; + } + + @Override + public boolean add(E aElement) { + if (mAllowNulls || aElement != null) return super.add(aElement); + return false; + } + + @Override + public void add(int aIndex, E aElement) { + if (mAllowNulls || aElement != null) super.add(aIndex, aElement); + } + + @Override + public boolean addAll(Collection<? extends E> aList) { + boolean rReturn = super.addAll(aList); + if (!mAllowNulls) for (int i = 0; i < size(); i++) if (get(i) == null) remove(i--); + return rReturn; + } + + @Override + public boolean addAll(int aIndex, Collection<? extends E> aList) { + boolean rReturn = super.addAll(aIndex, aList); + if (!mAllowNulls) for (int i = 0; i < size(); i++) if (get(i) == null) remove(i--); + return rReturn; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java new file mode 100644 index 0000000000..caf46b3980 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java @@ -0,0 +1,94 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.ITexture; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.IIcon; + +public class GT_CopiedBlockTexture implements ITexture { + private final Block mBlock; + private final byte mSide, mMeta; + private final boolean mAllowAlpha; + /** + * DO NOT MANIPULATE THE VALUES INSIDE THIS ARRAY!!! + * <p/> + * Just set this variable to another different Array instead. + * Otherwise some colored things will get Problems. + */ + public short[] mRGBa; + + public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta, short[] aRGBa, boolean aAllowAlpha) { + if (aRGBa.length != 4) throw new IllegalArgumentException("RGBa doesn't have 4 Values @ GT_CopiedBlockTexture"); + mBlock = aBlock; + mRGBa = aRGBa; + mSide = (byte) aSide; + mMeta = (byte) aMeta; + mAllowAlpha = aAllowAlpha; + } + + public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta, short[] aRGBa) { + this(aBlock, aSide, aMeta, aRGBa, true); + } + + public GT_CopiedBlockTexture(Block aBlock, int aSide, int aMeta) { + this(aBlock, aSide, aMeta, Dyes._NULL.mRGBa); + } + + private IIcon getIcon(int aSide) { + if (mSide == 6) return mBlock.getIcon(aSide, mMeta); + return mBlock.getIcon(mSide, mMeta); + } + + @Override + public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(5); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); +// aRenderer.flipTexture = !aRenderer.flipTexture; + aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, aIcon); +// aRenderer.flipTexture = !aRenderer.flipTexture; + } + + @Override + public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(4); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, aIcon); + } + + @Override + public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(1); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 1.0F), (int) (mRGBa[1] * 1.0F), (int) (mRGBa[2] * 1.0F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, aIcon); + } + + @Override + public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(0); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, aIcon); + } + + @Override + public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(3); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, aIcon); + } + + @Override + public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + IIcon aIcon = getIcon(2); + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); +// aRenderer.flipTexture = !aRenderer.flipTexture; + aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, aIcon); +// aRenderer.flipTexture = !aRenderer.flipTexture; + } + + @Override + public boolean isValidTexture() { + return mBlock != null; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_Cover_Default.java b/src/main/java/gregtech/api/objects/GT_Cover_Default.java new file mode 100644 index 0000000000..bf3bc84497 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_Cover_Default.java @@ -0,0 +1,68 @@ +package gregtech.api.objects; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_Default extends GT_CoverBehavior { + /** + * This is the Dummy, if there is a generic Cover without behavior + */ + public GT_Cover_Default() { + super(); + } + + @Override + public boolean isSimpleCover() { + return true; + } + + @Override + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = ((aCoverVariable + 1) & 15); + GT_Utility.sendChatToPlayer(aPlayer, ((aCoverVariable & 1) != 0 ? "Redstone " : "") + ((aCoverVariable & 2) != 0 ? "Energy " : "") + ((aCoverVariable & 4) != 0 ? "Fluids " : "") + ((aCoverVariable & 8) != 0 ? "Items " : "")); + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 1) != 0; + } + + @Override + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 1) != 0; + } + + @Override + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 2) != 0; + } + + @Override + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 2) != 0; + } + + @Override + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return (aCoverVariable & 4) != 0; + } + + @Override + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return (aCoverVariable & 4) != 0; + } + + @Override + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return (aCoverVariable & 8) != 0; + } + + @Override + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return (aCoverVariable & 8) != 0; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_Cover_None.java b/src/main/java/gregtech/api/objects/GT_Cover_None.java new file mode 100644 index 0000000000..6514571924 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_Cover_None.java @@ -0,0 +1,90 @@ +package gregtech.api.objects; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_None extends GT_CoverBehavior { + + /** + * This is the Dummy, if there is no Cover + */ + public GT_Cover_None() { + } + + @Override + public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 10.0F; + } + + @Override + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean isGUIClickable(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return false; + } + + @Override + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + return false; + } + + @Override + public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) { + return true; + } + + @Override + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + return 0; + } + + @Override + public boolean isSimpleCover() { + return true; + } +} diff --git a/src/main/java/gregtech/api/objects/GT_Fluid.java b/src/main/java/gregtech/api/objects/GT_Fluid.java new file mode 100644 index 0000000000..119b32a22b --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_Fluid.java @@ -0,0 +1,28 @@ +package gregtech.api.objects; + +import gregtech.api.GregTech_API; +import net.minecraftforge.fluids.Fluid; + +import static gregtech.api.enums.GT_Values.RES_PATH_BLOCK; + +public class GT_Fluid extends Fluid implements Runnable { + public final String mTextureName; + private final short[] mRGBa; + + public GT_Fluid(String aName, String aTextureName, short[] aRGBa) { + super(aName); + mRGBa = aRGBa; + mTextureName = aTextureName; + GregTech_API.sGTBlockIconload.add(this); + } + + @Override + public int getColor() { + return (Math.max(0, Math.min(255, mRGBa[0])) << 16) | (Math.max(0, Math.min(255, mRGBa[1])) << 8) | Math.max(0, Math.min(255, mRGBa[2])); + } + + @Override + public void run() { + setIcons(GregTech_API.sBlockIcons.registerIcon(RES_PATH_BLOCK + "fluids/fluid." + mTextureName)); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_FluidStack.java b/src/main/java/gregtech/api/objects/GT_FluidStack.java new file mode 100644 index 0000000000..3f9e52818c --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_FluidStack.java @@ -0,0 +1,75 @@ +package gregtech.api.objects; + +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_Log; +import gregtech.api.util.GT_Utility; +import net.minecraftforge.common.ForgeVersion; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Map; + +/** + * Because Forge fucked this one up royally. + */ +public class GT_FluidStack extends FluidStack { + private static final Collection<GT_FluidStack> sAllFluidStacks = new ArrayList<GT_FluidStack>(5000); + private static volatile boolean lock = false; + private Fluid mFluid; + + public GT_FluidStack(Fluid aFluid, int aAmount) { + super(aFluid, aAmount); + mFluid = aFluid; + if(!GregTech_API.mServerStarted){sAllFluidStacks.add(this);} + } + + public GT_FluidStack(FluidStack aFluid) { + this(aFluid.getFluid(), aFluid.amount); + } + + public static synchronized void fixAllThoseFuckingFluidIDs() { + if (ForgeVersion.getBuildVersion() < 1355) { + while (lock) { + try { + Thread.sleep(1); + } catch (InterruptedException e) { + } + } + lock = true; + for (GT_FluidStack tFluid : sAllFluidStacks) tFluid.fixFluidIDForFucksSake(); + for (Map<Fluid, ?> tMap : GregTech_API.sFluidMappings) + try { + GT_Utility.reMap(tMap); + } catch (Throwable e) { + e.printStackTrace(GT_Log.err); + } + lock = false; + } + } + + public void fixFluidIDForFucksSake() { + if (ForgeVersion.getBuildVersion() < 1355) { + int fluidID; + try { + fluidID = this.getFluid().getID(); + } catch (Throwable e) { + System.err.println(e); + } + try { + fluidID = mFluid.getID(); + } catch (Throwable e) { + fluidID = -1; + } + } + } + + @Override + public FluidStack copy() { + if (ForgeVersion.getBuildVersion() < 1355) { + fixFluidIDForFucksSake(); + } + return new GT_FluidStack(this); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_HashSet.java b/src/main/java/gregtech/api/objects/GT_HashSet.java new file mode 100644 index 0000000000..cec006905b --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_HashSet.java @@ -0,0 +1,82 @@ +package gregtech.api.objects; + +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_Utility; +import net.minecraft.item.ItemStack; + +import java.util.*; + +public class GT_HashSet<E extends GT_ItemStack> extends AbstractSet<E> { + private static final Object OBJECT = new Object(); + private transient HashMap<GT_ItemStack, Object> map; + + public GT_HashSet() { + map = new HashMap<GT_ItemStack, Object>(); + GregTech_API.sItemStackMappings.add(map); + } + + public GT_HashSet(Collection<? extends E> c) { + map = new HashMap<GT_ItemStack, Object>(Math.max((int) (c.size() / .75f) + 1, 16)); + addAll(c); + GregTech_API.sItemStackMappings.add(map); + } + + public GT_HashSet(int initialCapacity, float loadFactor) { + map = new HashMap<GT_ItemStack, Object>(initialCapacity, loadFactor); + GregTech_API.sItemStackMappings.add(map); + } + + public GT_HashSet(int initialCapacity) { + map = new HashMap<GT_ItemStack, Object>(initialCapacity); + GregTech_API.sItemStackMappings.add(map); + } + + GT_HashSet(int initialCapacity, float loadFactor, boolean dummy) { + map = new LinkedHashMap<GT_ItemStack, Object>(initialCapacity, loadFactor); + GregTech_API.sItemStackMappings.add(map); + } + + public HashMap getMap() { + return map; + } + + @Override + public Iterator<E> iterator() { + return (Iterator<E>) map.keySet().iterator(); + } + + @Override + public int size() { + return map.size(); + } + + @Override + public boolean isEmpty() { + return map.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return map.containsKey(o); + } + + public boolean add(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack)) return false; + return map.put(new GT_ItemStack(aStack), OBJECT) == null; + } + + @Override + public boolean add(E e) { + return map.put(e, OBJECT) == null; + } + + @Override + public boolean remove(Object o) { + return map.remove(o) == OBJECT; + } + + @Override + public void clear() { + map.clear(); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_ItemStack.java b/src/main/java/gregtech/api/objects/GT_ItemStack.java new file mode 100644 index 0000000000..f865b348a0 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_ItemStack.java @@ -0,0 +1,53 @@ +package gregtech.api.objects; + +import gregtech.api.util.GT_Utility; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class GT_ItemStack { + public final Item mItem; + public final byte mStackSize; + public final short mMetaData; + + public GT_ItemStack(Item aItem, long aStackSize, long aMetaData) { + mItem = aItem; + mStackSize = (byte) aStackSize; + mMetaData = (short) aMetaData; + } + + public GT_ItemStack(ItemStack aStack) { + this(aStack == null ? null : aStack.getItem(), aStack == null ? 0 : aStack.stackSize, aStack == null ? 0 : Items.feather.getDamage(aStack)); + } + + public GT_ItemStack(int aHashCode) { + this(GT_Utility.intToStack(aHashCode)); + } + + public ItemStack toStack() { + if (mItem == null) return null; + return new ItemStack(mItem, 1, mMetaData); + } + + public boolean isStackEqual(ItemStack aStack) { + return GT_Utility.areStacksEqual(toStack(), aStack); + } + + public boolean isStackEqual(GT_ItemStack aStack) { + return GT_Utility.areStacksEqual(toStack(), aStack.toStack()); + } + + @Override + public boolean equals(Object aStack) { + if (aStack == this) return true; + if (aStack instanceof GT_ItemStack) { + return ((GT_ItemStack) aStack).mItem == mItem && ((GT_ItemStack) aStack).mMetaData == mMetaData; + } + return false; + } + + @Override + public int hashCode() { + return GT_Utility.stackToInt(toStack()); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_MultiTexture.java b/src/main/java/gregtech/api/objects/GT_MultiTexture.java new file mode 100644 index 0000000000..8f1dbc7a62 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_MultiTexture.java @@ -0,0 +1,59 @@ +package gregtech.api.objects; + +import gregtech.api.interfaces.ITexture; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; + +/** + * Lets Multiple ITextures Render overlay over each other. + * <p/> + * I should have done this much earlier... + */ +public class GT_MultiTexture implements ITexture { + private final ITexture[] mTextures; + + public GT_MultiTexture(ITexture... aTextures) { + mTextures = aTextures; + } + + @Override + public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderXPos(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderXNeg(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderYPos(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderYNeg(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderZPos(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + for (ITexture tTexture : mTextures) + if (tTexture != null && tTexture.isValidTexture()) tTexture.renderZNeg(aRenderer, aBlock, aX, aY, aZ); + } + + @Override + public boolean isValidTexture() { + return true; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_RenderedTexture.java b/src/main/java/gregtech/api/objects/GT_RenderedTexture.java new file mode 100644 index 0000000000..e1627da287 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_RenderedTexture.java @@ -0,0 +1,138 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.IColorModulationContainer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.IIcon; + +public class GT_RenderedTexture implements ITexture, IColorModulationContainer { + private final IIconContainer mIconContainer; + private final boolean mAllowAlpha; + /** + * DO NOT MANIPULATE THE VALUES INSIDE THIS ARRAY!!! + * <p/> + * Just set this variable to another different Array instead. + * Otherwise some colored things will get Problems. + */ + public short[] mRGBa; + + public GT_RenderedTexture(IIconContainer aIcon, short[] aRGBa, boolean aAllowAlpha) { + if (aRGBa.length != 4) throw new IllegalArgumentException("RGBa doesn't have 4 Values @ GT_RenderedTexture"); + mIconContainer = aIcon; + mAllowAlpha = aAllowAlpha; + mRGBa = aRGBa; + } + + public GT_RenderedTexture(IIconContainer aIcon, short[] aRGBa) { + this(aIcon, aRGBa, true); + } + + public GT_RenderedTexture(IIconContainer aIcon) { + this(aIcon, Dyes._NULL.mRGBa); + } + + @Override + public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(153, 153, 153, 255); + aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } + + @Override + public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(153, 153, 153, 255); + aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } + + @Override + public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 1.0F), (int) (mRGBa[1] * 1.0F), (int) (mRGBa[2] * 1.0F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(255, 255, 255, 255); + aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } + + @Override + public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255); + IIcon aIcon = mIconContainer.getIcon(); + + double d3 = aIcon.getInterpolatedU(aRenderer.renderMaxX * 16.0D); + double d4 = aIcon.getInterpolatedU(aRenderer.renderMinX * 16.0D); + double d5 = aIcon.getInterpolatedV(aRenderer.renderMinZ * 16.0D); + double d6 = aIcon.getInterpolatedV(aRenderer.renderMaxZ * 16.0D); + + if (aRenderer.renderMinX < 0.0D || aRenderer.renderMaxX > 1.0D) { + d3 = aIcon.getMaxU(); + d4 = aIcon.getMinU(); + } + + if (aRenderer.renderMinZ < 0.0D || aRenderer.renderMaxZ > 1.0D) { + d5 = aIcon.getMinV(); + d6 = aIcon.getMaxV(); + } + + double d11 = aX + aRenderer.renderMinX; + double d12 = aX + aRenderer.renderMaxX; + double d13 = aY + aRenderer.renderMinY; + double d14 = aZ + aRenderer.renderMinZ; + double d15 = aZ + aRenderer.renderMaxZ; + + Tessellator.instance.addVertexWithUV(d11, d13, d15, d3, d6); + Tessellator.instance.addVertexWithUV(d11, d13, d14, d3, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d14, d4, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d15, d4, d6); + + if ((aIcon = mIconContainer.getOverlayIcon()) != null) { + Tessellator.instance.setColorRGBA(128, 128, 128, 255); + + Tessellator.instance.addVertexWithUV(d11, d13, d15, d3, d6); + Tessellator.instance.addVertexWithUV(d11, d13, d14, d3, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d14, d4, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d15, d4, d6); + } + } + + @Override + public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(204, 204, 204, 255); + aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } + + @Override + public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(204, 204, 204, 255); + aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } + + @Override + public short[] getRGBA() { + return mRGBa; + } + + @Override + public boolean isValidTexture() { + return mIconContainer != null; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/GT_SidedTexture.java b/src/main/java/gregtech/api/objects/GT_SidedTexture.java new file mode 100644 index 0000000000..2d27ecbc25 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GT_SidedTexture.java @@ -0,0 +1,167 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.IColorModulationContainer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.IIcon; + +public class GT_SidedTexture implements ITexture, IColorModulationContainer { + private final IIconContainer[] mIconContainer; + private final boolean mAllowAlpha; + /** + * DO NOT MANIPULATE THE VALUES INSIDE THIS ARRAY!!! + * <p/> + * Just set this variable to another different Array instead. + * Otherwise some colored things will get Problems. + */ + public short[] mRGBa; + + public GT_SidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, IIconContainer aIcon4, IIconContainer aIcon5, short[] aRGBa, boolean aAllowAlpha) { + if (aRGBa.length != 4) throw new IllegalArgumentException("RGBa doesn't have 4 Values @ GT_RenderedTexture"); + mIconContainer = new IIconContainer[]{aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5}; + mAllowAlpha = aAllowAlpha; + mRGBa = aRGBa; + } + + public GT_SidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, IIconContainer aIcon4, IIconContainer aIcon5, short[] aRGBa) { + this(aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5, aRGBa, true); + } + + public GT_SidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, IIconContainer aIcon4, IIconContainer aIcon5) { + this(aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5, Dyes._NULL.mRGBa); + } + + public GT_SidedTexture(IIconContainer aBottom, IIconContainer aTop, IIconContainer aSides, short[] aRGBa) { + this(aBottom, aTop, aSides, aSides, aSides, aSides, aRGBa); + } + + public GT_SidedTexture(IIconContainer aBottom, IIconContainer aTop, IIconContainer aSides) { + this(aBottom, aTop, aSides, Dyes._NULL.mRGBa); + } + + @Override + public void renderXPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer[5].getIcon()); + if (mIconContainer[5].getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(153, 153, 153, 255); + aRenderer.renderFaceXPos(aBlock, aX, aY, aZ, mIconContainer[5].getOverlayIcon()); + } + } + + @Override + public void renderXNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.6F), (int) (mRGBa[1] * 0.6F), (int) (mRGBa[2] * 0.6F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer[4].getIcon()); + if (mIconContainer[4].getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(153, 153, 153, 255); + aRenderer.renderFaceXNeg(aBlock, aX, aY, aZ, mIconContainer[4].getOverlayIcon()); + } + } + + @Override + public void renderYPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 1.0F), (int) (mRGBa[1] * 1.0F), (int) (mRGBa[2] * 1.0F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer[1].getIcon()); + if (mIconContainer[1].getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(255, 255, 255, 255); + aRenderer.renderFaceYPos(aBlock, aX, aY, aZ, mIconContainer[1].getOverlayIcon()); + } + } + + @Override + public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.5F), (int) (mRGBa[1] * 0.5F), (int) (mRGBa[2] * 0.5F), mAllowAlpha ? 255 - mRGBa[3] : 255); + IIcon aIcon = mIconContainer[0].getIcon(); + + double d3 = aIcon.getInterpolatedU(aRenderer.renderMaxX * 16.0D); + double d4 = aIcon.getInterpolatedU(aRenderer.renderMinX * 16.0D); + double d5 = aIcon.getInterpolatedV(aRenderer.renderMinZ * 16.0D); + double d6 = aIcon.getInterpolatedV(aRenderer.renderMaxZ * 16.0D); + + if (aRenderer.renderMinX < 0.0D || aRenderer.renderMaxX > 1.0D) { + d3 = aIcon.getMaxU(); + d4 = aIcon.getMinU(); + } + + if (aRenderer.renderMinZ < 0.0D || aRenderer.renderMaxZ > 1.0D) { + d5 = aIcon.getMinV(); + d6 = aIcon.getMaxV(); + } + + double d11 = aX + aRenderer.renderMinX; + double d12 = aX + aRenderer.renderMaxX; + double d13 = aY + aRenderer.renderMinY; + double d14 = aZ + aRenderer.renderMinZ; + double d15 = aZ + aRenderer.renderMaxZ; + + Tessellator.instance.addVertexWithUV(d11, d13, d15, d3, d6); + Tessellator.instance.addVertexWithUV(d11, d13, d14, d3, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d14, d4, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d15, d4, d6); + + if ((aIcon = mIconContainer[0].getOverlayIcon()) != null) { + Tessellator.instance.setColorRGBA(128, 128, 128, 255); + + d3 = aIcon.getInterpolatedU(aRenderer.renderMaxX * 16.0D); + d4 = aIcon.getInterpolatedU(aRenderer.renderMinX * 16.0D); + d5 = aIcon.getInterpolatedV(aRenderer.renderMinZ * 16.0D); + d6 = aIcon.getInterpolatedV(aRenderer.renderMaxZ * 16.0D); + + if (aRenderer.renderMinX < 0.0D || aRenderer.renderMaxX > 1.0D) { + d3 = aIcon.getMaxU(); + d4 = aIcon.getMinU(); + } + + if (aRenderer.renderMinZ < 0.0D || aRenderer.renderMaxZ > 1.0D) { + d5 = aIcon.getMinV(); + d6 = aIcon.getMaxV(); + } + + d11 = aX + aRenderer.renderMinX; + d12 = aX + aRenderer.renderMaxX; + d13 = aY + aRenderer.renderMinY; + d14 = aZ + aRenderer.renderMinZ; + d15 = aZ + aRenderer.renderMaxZ; + + Tessellator.instance.addVertexWithUV(d11, d13, d15, d3, d6); + Tessellator.instance.addVertexWithUV(d11, d13, d14, d3, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d14, d4, d5); + Tessellator.instance.addVertexWithUV(d12, d13, d15, d4, d6); + } + } + + @Override + public void renderZPos(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer[3].getIcon()); + if (mIconContainer[3].getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(204, 204, 204, 255); + aRenderer.renderFaceZPos(aBlock, aX, aY, aZ, mIconContainer[3].getOverlayIcon()); + } + } + + @Override + public void renderZNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + Tessellator.instance.setColorRGBA((int) (mRGBa[0] * 0.8F), (int) (mRGBa[1] * 0.8F), (int) (mRGBa[2] * 0.8F), mAllowAlpha ? 255 - mRGBa[3] : 255); + aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer[2].getIcon()); + if (mIconContainer[2].getOverlayIcon() != null) { + Tessellator.instance.setColorRGBA(204, 204, 204, 255); + aRenderer.renderFaceZNeg(aBlock, aX, aY, aZ, mIconContainer[2].getOverlayIcon()); + } + } + + @Override + public short[] getRGBA() { + return mRGBa; + } + + @Override + public boolean isValidTexture() { + return mIconContainer != null && mIconContainer[0] != null && mIconContainer[1] != null && mIconContainer[2] != null && mIconContainer[3] != null && mIconContainer[4] != null && mIconContainer[5] != null; + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/ItemData.java b/src/main/java/gregtech/api/objects/ItemData.java new file mode 100644 index 0000000000..aedc48db5a --- /dev/null +++ b/src/main/java/gregtech/api/objects/ItemData.java @@ -0,0 +1,124 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import net.minecraft.item.ItemStack; + +import java.util.*; + +public class ItemData { + private static final MaterialStack[] EMPTY_MATERIALSTACK_ARRAY = new MaterialStack[0]; + + public final List<Object> mExtraData = new GT_ArrayList<Object>(false, 1); + public final OrePrefixes mPrefix; + public final MaterialStack mMaterial; + public final MaterialStack[] mByProducts; + public boolean mBlackListed = false; + public ItemStack mUnificationTarget = null; + + public ItemData(OrePrefixes aPrefix, Materials aMaterial, boolean aBlackListed) { + mPrefix = aPrefix; + mMaterial = aMaterial == null ? null : new MaterialStack(aMaterial, aPrefix.mMaterialAmount); + mBlackListed = aBlackListed; + mByProducts = aPrefix.mSecondaryMaterial == null || aPrefix.mSecondaryMaterial.mMaterial == null ? EMPTY_MATERIALSTACK_ARRAY : new MaterialStack[]{aPrefix.mSecondaryMaterial.clone()}; + } + + public ItemData(OrePrefixes aPrefix, Materials aMaterial) { + this(aPrefix, aMaterial, false); + } + + public ItemData(MaterialStack aMaterial, MaterialStack... aByProducts) { + mPrefix = null; + mMaterial = aMaterial.mMaterial == null ? null : aMaterial.clone(); + mBlackListed = true; + if (aByProducts == null) { + mByProducts = EMPTY_MATERIALSTACK_ARRAY; + } else { + MaterialStack[] tByProducts = aByProducts.length < 1 ? EMPTY_MATERIALSTACK_ARRAY : new MaterialStack[aByProducts.length]; + int j = 0; + for (int i = 0; i < aByProducts.length; i++) + if (aByProducts[i] != null && aByProducts[i].mMaterial != null) + tByProducts[j++] = aByProducts[i].clone(); + mByProducts = j > 0 ? new MaterialStack[j] : EMPTY_MATERIALSTACK_ARRAY; + for (int i = 0; i < mByProducts.length; i++) mByProducts[i] = tByProducts[i]; + } + } + + public ItemData(Materials aMaterial, long aAmount, MaterialStack... aByProducts) { + this(new MaterialStack(aMaterial, aAmount), aByProducts); + } + + public ItemData(Materials aMaterial, long aAmount, Materials aByProduct, long aByProductAmount) { + this(new MaterialStack(aMaterial, aAmount), new MaterialStack(aByProduct, aByProductAmount)); + } + + public ItemData(ItemData... aData) { + mPrefix = null; + mBlackListed = true; + + ArrayList<MaterialStack> aList = new ArrayList<MaterialStack>(), rList = new ArrayList<MaterialStack>(); + + for (ItemData tData : aData) + if (tData != null) { + if (tData.hasValidMaterialData() && tData.mMaterial.mAmount > 0) aList.add(tData.mMaterial.clone()); + for (MaterialStack tMaterial : tData.mByProducts) + if (tMaterial.mAmount > 0) aList.add(tMaterial.clone()); + } + + for (MaterialStack aMaterial : aList) { + boolean temp = true; + for (MaterialStack tMaterial : rList) + if (aMaterial.mMaterial == tMaterial.mMaterial) { + tMaterial.mAmount += aMaterial.mAmount; + temp = false; + break; + } + if (temp) rList.add(aMaterial.clone()); + } + + Collections.sort(rList, new Comparator<MaterialStack>() { + @Override + public int compare(MaterialStack a, MaterialStack b) { + return a.mAmount == b.mAmount ? 0 : a.mAmount > b.mAmount ? -1 : +1; + } + }); + + if (rList.isEmpty()) { + mMaterial = null; + } else { + mMaterial = rList.get(0); + rList.remove(0); + } + + mByProducts = rList.toArray(new MaterialStack[rList.size()]); + } + + public boolean hasValidPrefixMaterialData() { + return mPrefix != null && mMaterial != null && mMaterial.mMaterial != null; + } + + public boolean hasValidPrefixData() { + return mPrefix != null; + } + + public boolean hasValidMaterialData() { + return mMaterial != null && mMaterial.mMaterial != null; + } + + public ArrayList<MaterialStack> getAllMaterialStacks() { + ArrayList<MaterialStack> rList = new ArrayList(); + if (hasValidMaterialData()) rList.add(mMaterial); + rList.addAll(Arrays.asList(mByProducts)); + return rList; + } + + public MaterialStack getByProduct(int aIndex) { + return aIndex >= 0 && aIndex < mByProducts.length ? mByProducts[aIndex] : null; + } + + @Override + public String toString() { + if (mPrefix == null || mMaterial == null || mMaterial.mMaterial == null) return ""; + return mPrefix.name() + mMaterial.mMaterial.name(); + } +}
\ No newline at end of file diff --git a/src/main/java/gregtech/api/objects/MaterialStack.java b/src/main/java/gregtech/api/objects/MaterialStack.java new file mode 100644 index 0000000000..5ddb88423a --- /dev/null +++ b/src/main/java/gregtech/api/objects/MaterialStack.java @@ -0,0 +1,42 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Materials; + +public class MaterialStack implements Cloneable { + public long mAmount; + public Materials mMaterial; + + public MaterialStack(Materials aMaterial, long aAmount) { + mMaterial = aMaterial == null ? Materials._NULL : aMaterial; + mAmount = aAmount; + } + + public MaterialStack copy(long aAmount) { + return new MaterialStack(mMaterial, aAmount); + } + + @Override + public MaterialStack clone() { + return new MaterialStack(mMaterial, mAmount); + } + + @Override + public boolean equals(Object aObject) { + if (aObject == this) return true; + if (aObject == null) return false; + if (aObject instanceof Materials) return aObject == mMaterial; + if (aObject instanceof MaterialStack) + return ((MaterialStack) aObject).mMaterial == mMaterial && (mAmount < 0 || ((MaterialStack) aObject).mAmount < 0 || ((MaterialStack) aObject).mAmount == mAmount); + return false; + } + + @Override + public String toString() { + return (mMaterial.mMaterialList.size() > 1 && mAmount > 1 ? "(" : "") + mMaterial.getToolTip(true) + (mMaterial.mMaterialList.size() > 1 && mAmount > 1 ? ")" : "") + (mAmount > 1 ? mAmount : ""); + } + + @Override + public int hashCode() { + return mMaterial.hashCode(); + } +}
\ No newline at end of file |