678 lines
22 KiB
Java
678 lines
22 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.util.item;
|
|
|
|
import java.io.*;
|
|
import java.security.InvalidParameterException;
|
|
import java.util.List;
|
|
import javax.annotation.Nullable;
|
|
|
|
import appeng.api.config.FuzzyMode;
|
|
import appeng.api.storage.StorageChannel;
|
|
import appeng.api.storage.data.IAEItemStack;
|
|
import appeng.api.storage.data.IAETagCompound;
|
|
import appeng.util.Platform;
|
|
import cpw.mods.fml.common.registry.GameRegistry;
|
|
import cpw.mods.fml.common.registry.GameRegistry.UniqueIdentifier;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.CompressedStreamTools;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
|
|
public final class AEItemStack
|
|
extends AEStack<IAEItemStack> implements IAEItemStack, Comparable<AEItemStack> {
|
|
private AEItemDef def;
|
|
|
|
private AEItemStack(final AEItemStack is) {
|
|
this.setDefinition(is.getDefinition());
|
|
this.setStackSize(is.getStackSize());
|
|
this.setCraftable(is.isCraftable());
|
|
this.setCountRequestable(is.getCountRequestable());
|
|
}
|
|
|
|
private AEItemStack(final ItemStack is) {
|
|
if (is == null) {
|
|
throw new InvalidParameterException(
|
|
"null is not a valid ItemStack for AEItemStack."
|
|
);
|
|
}
|
|
|
|
final Item item = is.getItem();
|
|
if (item == null) {
|
|
throw new InvalidParameterException(
|
|
"Contained item is null, thus not a valid ItemStack for AEItemStack."
|
|
);
|
|
}
|
|
|
|
this.setDefinition(new AEItemDef(item));
|
|
|
|
if (this.getDefinition().getItem() == null) {
|
|
throw new InvalidParameterException(
|
|
"This ItemStack is bad, it has a null item."
|
|
);
|
|
}
|
|
|
|
/*
|
|
* Prevent an Item from changing the damage value on me... Either, this or a core
|
|
* mod.
|
|
*/
|
|
|
|
/*
|
|
* Super hackery.
|
|
* is.itemID = appeng.api.Materials.matQuartz.itemID; damageValue =
|
|
* is.getItemDamage(); is.itemID = itemID;
|
|
*/
|
|
|
|
/*
|
|
* Kinda hackery
|
|
*/
|
|
this.getDefinition().setDamageValue(this.getDefinition().getDamageValueHack(is));
|
|
this.getDefinition().setDisplayDamage(is.getItemDamageForDisplay());
|
|
this.getDefinition().setMaxDamage(is.getMaxDamage());
|
|
|
|
final NBTTagCompound tagCompound = is.getTagCompound();
|
|
if (tagCompound != null) {
|
|
this.getDefinition().setTagCompound((AESharedNBT
|
|
) AESharedNBT.getSharedTagCompound(tagCompound, is));
|
|
}
|
|
|
|
this.setStackSize(is.stackSize);
|
|
this.setCraftable(false);
|
|
this.setCountRequestable(0);
|
|
|
|
this.getDefinition().reHash();
|
|
this.getDefinition().setIsOre(OreHelper.INSTANCE.isOre(is));
|
|
}
|
|
|
|
public static IAEItemStack loadItemStackFromNBT(final NBTTagCompound i) {
|
|
if (i == null) {
|
|
return null;
|
|
}
|
|
|
|
final ItemStack itemstack = ItemStack.loadItemStackFromNBT(i);
|
|
if (itemstack == null) {
|
|
return null;
|
|
}
|
|
|
|
final AEItemStack item = AEItemStack.create(itemstack);
|
|
// item.priority = i.getInteger( "Priority" );
|
|
item.setStackSize(i.getLong("Cnt"));
|
|
item.setCountRequestable(i.getLong("Req"));
|
|
item.setCraftable(i.getBoolean("Craft"));
|
|
return item;
|
|
}
|
|
|
|
@Nullable
|
|
public static AEItemStack create(final ItemStack stack) {
|
|
if (stack == null) {
|
|
return null;
|
|
}
|
|
|
|
return new AEItemStack(stack);
|
|
}
|
|
|
|
public static IAEItemStack loadItemStackFromPacket(final ByteBuf data)
|
|
throws IOException {
|
|
final byte mask = data.readByte();
|
|
// byte PriorityType = (byte) (mask & 0x03);
|
|
final byte stackType = (byte) ((mask & 0x0C) >> 2);
|
|
final byte countReqType = (byte) ((mask & 0x30) >> 4);
|
|
final boolean isCraftable = (mask & 0x40) > 0;
|
|
final boolean hasTagCompound = (mask & 0x80) > 0;
|
|
|
|
// don't send this...
|
|
final NBTTagCompound d = new NBTTagCompound();
|
|
|
|
d.setShort("id", data.readShort());
|
|
d.setShort("Damage", data.readShort());
|
|
d.setByte("Count", (byte) 0);
|
|
|
|
if (hasTagCompound) {
|
|
final int len = data.readInt();
|
|
|
|
final byte[] bd = new byte[len];
|
|
data.readBytes(bd);
|
|
|
|
final ByteArrayInputStream di = new ByteArrayInputStream(bd);
|
|
d.setTag("tag", CompressedStreamTools.read(new DataInputStream(di)));
|
|
}
|
|
|
|
// long priority = getPacketValue( PriorityType, data );
|
|
final long stackSize = getPacketValue(stackType, data);
|
|
final long countRequestable = getPacketValue(countReqType, data);
|
|
|
|
final ItemStack itemstack = ItemStack.loadItemStackFromNBT(d);
|
|
if (itemstack == null) {
|
|
return null;
|
|
}
|
|
|
|
final AEItemStack item = AEItemStack.create(itemstack);
|
|
// item.priority = (int) priority;
|
|
item.setStackSize(stackSize);
|
|
item.setCountRequestable(countRequestable);
|
|
item.setCraftable(isCraftable);
|
|
return item;
|
|
}
|
|
|
|
@Override
|
|
public void add(final IAEItemStack option) {
|
|
if (option == null) {
|
|
return;
|
|
}
|
|
|
|
// if ( priority < ((AEItemStack) option).priority )
|
|
// priority = ((AEItemStack) option).priority;
|
|
|
|
this.incStackSize(option.getStackSize());
|
|
this.setCountRequestable(
|
|
this.getCountRequestable() + option.getCountRequestable()
|
|
);
|
|
this.setCraftable(this.isCraftable() || option.isCraftable());
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(final NBTTagCompound i) {
|
|
/*
|
|
* Mojang Fucked this over ; GC Optimization - Ugly Yes, but it saves a lot in the
|
|
* memory department.
|
|
*/
|
|
|
|
/*
|
|
* NBTBase id = i.getTag( "id" ); NBTBase Count = i.getTag( "Count" ); NBTBase Cnt
|
|
* = i.getTag( "Cnt" ); NBTBase Req = i.getTag( "Req" ); NBTBase Craft = i.getTag(
|
|
* "Craft" ); NBTBase Damage = i.getTag( "Damage" );
|
|
*/
|
|
|
|
/*
|
|
* if ( id != null && id instanceof NBTTagShort ) ((NBTTagShort) id).data =
|
|
* (short) this.def.item.itemID; else
|
|
*/
|
|
i.setShort(
|
|
"id", (short) Item.itemRegistry.getIDForObject(this.getDefinition().getItem())
|
|
);
|
|
|
|
/*
|
|
* if ( Count != null && Count instanceof NBTTagByte ) ((NBTTagByte) Count).data =
|
|
* (byte) 0; else
|
|
*/
|
|
i.setByte("Count", (byte) 0);
|
|
|
|
/*
|
|
* if ( Cnt != null && Cnt instanceof NBTTagLong ) ((NBTTagLong) Cnt).data =
|
|
* this.stackSize; else
|
|
*/
|
|
i.setLong("Cnt", this.getStackSize());
|
|
|
|
/*
|
|
* if ( Req != null && Req instanceof NBTTagLong ) ((NBTTagLong) Req).data =
|
|
* this.stackSize; else
|
|
*/
|
|
i.setLong("Req", this.getCountRequestable());
|
|
|
|
/*
|
|
* if ( Craft != null && Craft instanceof NBTTagByte ) ((NBTTagByte) Craft).data =
|
|
* (byte) (this.isCraftable() ? 1 : 0); else
|
|
*/
|
|
i.setBoolean("Craft", this.isCraftable());
|
|
|
|
/*
|
|
* if ( Damage != null && Damage instanceof NBTTagShort ) ((NBTTagShort)
|
|
* Damage).data = (short) this.def.damageValue; else
|
|
*/
|
|
i.setShort("Damage", (short) this.getDefinition().getDamageValue());
|
|
|
|
if (this.getDefinition().getTagCompound() != null) {
|
|
i.setTag("tag", this.getDefinition().getTagCompound());
|
|
} else {
|
|
i.removeTag("tag");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean fuzzyComparison(final Object st, final FuzzyMode mode) {
|
|
if (st instanceof IAEItemStack) {
|
|
final IAEItemStack o = (IAEItemStack) st;
|
|
|
|
if (this.sameOre(o)) {
|
|
return true;
|
|
}
|
|
|
|
if (o.getItem() == this.getItem()) {
|
|
if (this.getDefinition().getItem().isDamageable()) {
|
|
final ItemStack a = this.getItemStack();
|
|
final ItemStack b = o.getItemStack();
|
|
|
|
try {
|
|
if (mode == FuzzyMode.IGNORE_ALL) {
|
|
return true;
|
|
} else if (mode == FuzzyMode.PERCENT_99) {
|
|
return (a.getItemDamageForDisplay() > 1)
|
|
== (b.getItemDamageForDisplay() > 1);
|
|
} else {
|
|
final float percentDamageOfA = 1.0f
|
|
- (float) a.getItemDamageForDisplay()
|
|
/ (float) a.getMaxDamage();
|
|
final float percentDamageOfB = 1.0f
|
|
- (float) b.getItemDamageForDisplay()
|
|
/ (float) b.getMaxDamage();
|
|
|
|
return (percentDamageOfA > mode.breakPoint)
|
|
== (percentDamageOfB > mode.breakPoint);
|
|
}
|
|
} catch (final Throwable e) {
|
|
if (mode == FuzzyMode.IGNORE_ALL) {
|
|
return true;
|
|
} else if (mode == FuzzyMode.PERCENT_99) {
|
|
return (a.getItemDamage() > 1) == (b.getItemDamage() > 1);
|
|
} else {
|
|
final float percentDamageOfA
|
|
= (float) a.getItemDamage() / (float) a.getMaxDamage();
|
|
final float percentDamageOfB
|
|
= (float) b.getItemDamage() / (float) b.getMaxDamage();
|
|
|
|
return (percentDamageOfA > mode.breakPoint)
|
|
== (percentDamageOfB > mode.breakPoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
return this.getItemDamage() == o.getItemDamage();
|
|
}
|
|
}
|
|
|
|
if (st instanceof ItemStack) {
|
|
final ItemStack o = (ItemStack) st;
|
|
|
|
OreHelper.INSTANCE.sameOre(this, o);
|
|
|
|
if (o.getItem() == this.getItem()) {
|
|
if (this.getDefinition().getItem().isDamageable()) {
|
|
final ItemStack a = this.getItemStack();
|
|
|
|
try {
|
|
if (mode == FuzzyMode.IGNORE_ALL) {
|
|
return true;
|
|
} else if (mode == FuzzyMode.PERCENT_99) {
|
|
return (a.getItemDamageForDisplay() > 1)
|
|
== (o.getItemDamageForDisplay() > 1);
|
|
} else {
|
|
final float percentDamageOfA = 1.0f
|
|
- (float) a.getItemDamageForDisplay()
|
|
/ (float) a.getMaxDamage();
|
|
final float percentDamageOfB = 1.0f
|
|
- (float) o.getItemDamageForDisplay()
|
|
/ (float) o.getMaxDamage();
|
|
|
|
return (percentDamageOfA > mode.breakPoint)
|
|
== (percentDamageOfB > mode.breakPoint);
|
|
}
|
|
} catch (final Throwable e) {
|
|
if (mode == FuzzyMode.IGNORE_ALL) {
|
|
return true;
|
|
} else if (mode == FuzzyMode.PERCENT_99) {
|
|
return (a.getItemDamage() > 1) == (o.getItemDamage() > 1);
|
|
} else {
|
|
final float percentDamageOfA
|
|
= (float) a.getItemDamage() / (float) a.getMaxDamage();
|
|
final float percentDamageOfB
|
|
= (float) o.getItemDamage() / (float) o.getMaxDamage();
|
|
|
|
return (percentDamageOfA > mode.breakPoint)
|
|
== (percentDamageOfB > mode.breakPoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
return this.getItemDamage() == o.getItemDamage();
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public IAEItemStack copy() {
|
|
return new AEItemStack(this);
|
|
}
|
|
|
|
@Override
|
|
public IAEItemStack empty() {
|
|
final IAEItemStack dup = this.copy();
|
|
dup.reset();
|
|
return dup;
|
|
}
|
|
|
|
@Override
|
|
public IAETagCompound getTagCompound() {
|
|
return this.getDefinition().getTagCompound();
|
|
}
|
|
|
|
@Override
|
|
public boolean isItem() {
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean isFluid() {
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public StorageChannel getChannel() {
|
|
return StorageChannel.ITEMS;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getItemStack() {
|
|
final ItemStack is = new ItemStack(
|
|
this.getDefinition().getItem(),
|
|
(int) Math.min(Integer.MAX_VALUE, this.getStackSize()),
|
|
this.getDefinition().getDamageValue()
|
|
);
|
|
if (this.getDefinition().getTagCompound() != null) {
|
|
is.setTagCompound(this.getDefinition().getTagCompound().getNBTTagCompoundCopy(
|
|
));
|
|
}
|
|
|
|
return is;
|
|
}
|
|
|
|
@Override
|
|
public Item getItem() {
|
|
return this.getDefinition().getItem();
|
|
}
|
|
|
|
@Override
|
|
public int getItemDamage() {
|
|
return this.getDefinition().getDamageValue();
|
|
}
|
|
|
|
@Override
|
|
public boolean sameOre(final IAEItemStack is) {
|
|
return OreHelper.INSTANCE.sameOre(this, is);
|
|
}
|
|
|
|
@Override
|
|
public boolean isSameType(final IAEItemStack otherStack) {
|
|
if (otherStack == null) {
|
|
return false;
|
|
}
|
|
|
|
return this.getDefinition().equals(((AEItemStack) otherStack).getDefinition());
|
|
}
|
|
|
|
@Override
|
|
public boolean isSameType(final ItemStack otherStack) {
|
|
if (otherStack == null) {
|
|
return false;
|
|
}
|
|
|
|
return this.getDefinition().isItem(otherStack);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return this.getDefinition().getMyHash();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(final Object ia) {
|
|
if (ia instanceof AEItemStack) {
|
|
return ((AEItemStack) ia)
|
|
.getDefinition()
|
|
.equals(this.getDefinition()); // && def.tagCompound ==
|
|
// ((AEItemStack)
|
|
// ia).def.tagCompound;
|
|
} else if (ia instanceof ItemStack) {
|
|
final ItemStack is = (ItemStack) ia;
|
|
|
|
if (is.getItem() == this.getDefinition().getItem()
|
|
&& is.getItemDamage() == this.getDefinition().getDamageValue()) {
|
|
final NBTTagCompound ta = this.getDefinition().getTagCompound();
|
|
final NBTTagCompound tb = is.getTagCompound();
|
|
if (ta == tb) {
|
|
return true;
|
|
}
|
|
|
|
if ((ta == null && tb == null)
|
|
|| (ta != null && ta.hasNoTags() && tb == null)
|
|
|| (tb != null && tb.hasNoTags() && ta == null)
|
|
|| (ta != null && ta.hasNoTags() && tb != null && tb.hasNoTags())) {
|
|
return true;
|
|
}
|
|
|
|
if ((ta == null && tb != null) || (ta != null && tb == null)) {
|
|
return false;
|
|
}
|
|
|
|
if (AESharedNBT.isShared(tb)) {
|
|
return ta == tb;
|
|
}
|
|
|
|
return Platform.NBTEqualityTest(ta, tb);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return this.getItemStack().toString();
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(final AEItemStack b) {
|
|
final int id = this.getDefinition().getItemID() - b.getDefinition().getItemID();
|
|
if (id != 0) {
|
|
return id;
|
|
}
|
|
|
|
final int damageValue
|
|
= this.getDefinition().getDamageValue() - b.getDefinition().getDamageValue();
|
|
if (damageValue != 0) {
|
|
return damageValue;
|
|
}
|
|
|
|
final int displayDamage = this.getDefinition().getDisplayDamage()
|
|
- b.getDefinition().getDisplayDamage();
|
|
if (displayDamage != 0) {
|
|
return displayDamage;
|
|
}
|
|
|
|
return (this.getDefinition().getTagCompound()
|
|
== b.getDefinition().getTagCompound())
|
|
? 0
|
|
: this.compareNBT(b.getDefinition());
|
|
}
|
|
|
|
private int compareNBT(final AEItemDef b) {
|
|
final int nbt = this.compare(
|
|
(this.getDefinition().getTagCompound() == null
|
|
? 0
|
|
: this.getDefinition().getTagCompound().getHash()),
|
|
(b.getTagCompound() == null ? 0 : b.getTagCompound().getHash())
|
|
);
|
|
if (nbt == 0) {
|
|
return this.compare(
|
|
System.identityHashCode(this.getDefinition().getTagCompound()),
|
|
System.identityHashCode(b.getTagCompound())
|
|
);
|
|
}
|
|
return nbt;
|
|
}
|
|
|
|
private int compare(final int l, final int m) {
|
|
return l < m ? -1 : (l > m ? 1 : 0);
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public List getToolTip() {
|
|
if (this.getDefinition().getTooltip() != null) {
|
|
return this.getDefinition().getTooltip();
|
|
}
|
|
|
|
return this.getDefinition().setTooltip(Platform.getTooltip(this.getItemStack()));
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public String getDisplayName() {
|
|
if (this.getDefinition().getDisplayName() == null) {
|
|
this.getDefinition().setDisplayName(
|
|
Platform.getItemDisplayName(this.getItemStack())
|
|
);
|
|
}
|
|
|
|
return this.getDefinition().getDisplayName();
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
public String getModID() {
|
|
if (this.getDefinition().getUniqueID() != null) {
|
|
return this.getModName(this.getDefinition().getUniqueID());
|
|
}
|
|
|
|
return this.getModName(this.getDefinition().setUniqueID(
|
|
GameRegistry.findUniqueIdentifierFor(this.getDefinition().getItem())
|
|
));
|
|
}
|
|
|
|
private String getModName(final UniqueIdentifier uniqueIdentifier) {
|
|
if (uniqueIdentifier == null) {
|
|
return "** Null";
|
|
}
|
|
|
|
return uniqueIdentifier.modId == null ? "** Null" : uniqueIdentifier.modId;
|
|
}
|
|
|
|
IAEItemStack getLow(final FuzzyMode fuzzy, final boolean ignoreMeta) {
|
|
final AEItemStack bottom = new AEItemStack(this);
|
|
final AEItemDef newDef = bottom.setDefinition(bottom.getDefinition().copy());
|
|
|
|
if (ignoreMeta) {
|
|
newDef.setDisplayDamage(newDef.setDamageValue(0));
|
|
newDef.reHash();
|
|
return bottom;
|
|
}
|
|
|
|
if (newDef.getItem().isDamageable()) {
|
|
if (fuzzy == FuzzyMode.IGNORE_ALL) {
|
|
newDef.setDisplayDamage(0);
|
|
} else if (fuzzy == FuzzyMode.PERCENT_99) {
|
|
if (this.getDefinition().getDamageValue() == 0) {
|
|
newDef.setDisplayDamage(0);
|
|
} else {
|
|
newDef.setDisplayDamage(1);
|
|
}
|
|
} else {
|
|
final int breakpoint
|
|
= fuzzy.calculateBreakPoint(this.getDefinition().getMaxDamage());
|
|
newDef.setDisplayDamage(
|
|
breakpoint <= this.getDefinition().getDisplayDamage() ? breakpoint : 0
|
|
);
|
|
}
|
|
|
|
newDef.setDamageValue(newDef.getDisplayDamage());
|
|
}
|
|
|
|
newDef.setTagCompound(AEItemDef.LOW_TAG);
|
|
newDef.reHash();
|
|
return bottom;
|
|
}
|
|
|
|
IAEItemStack getHigh(final FuzzyMode fuzzy, final boolean ignoreMeta) {
|
|
final AEItemStack top = new AEItemStack(this);
|
|
final AEItemDef newDef = top.setDefinition(top.getDefinition().copy());
|
|
|
|
if (ignoreMeta) {
|
|
newDef.setDisplayDamage(newDef.setDamageValue(Integer.MAX_VALUE));
|
|
newDef.reHash();
|
|
return top;
|
|
}
|
|
|
|
if (newDef.getItem().isDamageable()) {
|
|
if (fuzzy == FuzzyMode.IGNORE_ALL) {
|
|
newDef.setDisplayDamage(this.getDefinition().getMaxDamage() + 1);
|
|
} else if (fuzzy == FuzzyMode.PERCENT_99) {
|
|
if (this.getDefinition().getDamageValue() == 0) {
|
|
newDef.setDisplayDamage(0);
|
|
} else {
|
|
newDef.setDisplayDamage(this.getDefinition().getMaxDamage() + 1);
|
|
}
|
|
} else {
|
|
final int breakpoint
|
|
= fuzzy.calculateBreakPoint(this.getDefinition().getMaxDamage());
|
|
newDef.setDisplayDamage(
|
|
this.getDefinition().getDisplayDamage() < breakpoint
|
|
? breakpoint - 1
|
|
: this.getDefinition().getMaxDamage() + 1
|
|
);
|
|
}
|
|
|
|
newDef.setDamageValue(newDef.getDisplayDamage());
|
|
}
|
|
|
|
newDef.setTagCompound(AEItemDef.HIGH_TAG);
|
|
newDef.reHash();
|
|
return top;
|
|
}
|
|
|
|
public boolean isOre() {
|
|
return this.getDefinition().getIsOre() != null;
|
|
}
|
|
|
|
@Override
|
|
void writeIdentity(final ByteBuf i) throws IOException {
|
|
i.writeShort(Item.itemRegistry.getIDForObject(this.getDefinition().getItem()));
|
|
i.writeShort(this.getItemDamage());
|
|
}
|
|
|
|
@Override
|
|
void readNBT(final ByteBuf i) throws IOException {
|
|
if (this.hasTagCompound()) {
|
|
final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
|
|
final DataOutputStream data = new DataOutputStream(bytes);
|
|
|
|
CompressedStreamTools.write((NBTTagCompound) this.getTagCompound(), data);
|
|
|
|
final byte[] tagBytes = bytes.toByteArray();
|
|
final int size = tagBytes.length;
|
|
|
|
i.writeInt(size);
|
|
i.writeBytes(tagBytes);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean hasTagCompound() {
|
|
return this.getDefinition().getTagCompound() != null;
|
|
}
|
|
|
|
AEItemDef getDefinition() {
|
|
return this.def;
|
|
}
|
|
|
|
private AEItemDef setDefinition(final AEItemDef def) {
|
|
this.def = def;
|
|
return def;
|
|
}
|
|
}
|