AE2 First Commit, the dawn of 1.7 hast arrived.
This commit is contained in:
algorithmx2
@@ -0,0 +1,319 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.DataInput;
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.CompressedStreamTools;
|
||||
import net.minecraft.nbt.NBTBase;
|
||||
import net.minecraft.nbt.NBTTagByte;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagLong;
|
||||
import net.minecraft.nbt.NBTTagString;
|
||||
import net.minecraftforge.fluids.Fluid;
|
||||
import net.minecraftforge.fluids.FluidStack;
|
||||
import appeng.api.config.FuzzyMode;
|
||||
import appeng.api.storage.data.IAEFluidStack;
|
||||
import appeng.api.storage.data.IAETagCompound;
|
||||
import appeng.util.Platform;
|
||||
|
||||
import com.google.common.io.ByteStreams;
|
||||
|
||||
public final class AEFluidStack extends AEStack<IAEFluidStack> implements IAEFluidStack, Comparable<AEFluidStack>
|
||||
{
|
||||
|
||||
public int myHash;
|
||||
Fluid fluid;
|
||||
protected IAETagCompound tagCompound;
|
||||
|
||||
@Override
|
||||
public IAETagCompound getTagCompound()
|
||||
{
|
||||
return tagCompound;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void add(IAEFluidStack option)
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
// if ( priority < ((AEFluidStack) option).priority )
|
||||
// priority = ((AEFluidStack) option).priority;
|
||||
|
||||
incStackSize( option.getStackSize() );
|
||||
setCountRequestable( getCountRequestable() + option.getCountRequestable() );
|
||||
setCraftable( isCraftable() || option.isCraftable() );
|
||||
}
|
||||
|
||||
private AEFluidStack(AEFluidStack is) {
|
||||
stackSize = is.stackSize;
|
||||
// priority = is.priority;
|
||||
setCraftable( is.isCraftable() );
|
||||
setCountRequestable( is.getCountRequestable() );
|
||||
|
||||
this.myHash = is.myHash;
|
||||
}
|
||||
|
||||
protected AEFluidStack(FluidStack is) {
|
||||
if ( is == null )
|
||||
throw new RuntimeException( "Invalid Itemstack." );
|
||||
|
||||
fluid = is.getFluid();
|
||||
stackSize = is.amount;
|
||||
setCraftable( false );
|
||||
setCountRequestable( 0 );
|
||||
|
||||
myHash = fluid.hashCode() ^ (tagCompound == null ? 0 : System.identityHashCode( tagCompound ));
|
||||
}
|
||||
|
||||
public static AEFluidStack create(Object a)
|
||||
{
|
||||
if ( a == null )
|
||||
return null;
|
||||
if ( a instanceof AEFluidStack )
|
||||
((AEFluidStack) a).copy();
|
||||
if ( a instanceof FluidStack )
|
||||
return new AEFluidStack( (FluidStack) a );
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object ia)
|
||||
{
|
||||
if ( ia instanceof AEFluidStack )
|
||||
{
|
||||
return ((AEFluidStack) ia).fluid == fluid && tagCompound == ((AEFluidStack) ia).tagCompound;
|
||||
}
|
||||
else if ( ia instanceof FluidStack )
|
||||
{
|
||||
FluidStack is = (FluidStack) ia;
|
||||
|
||||
if ( is.fluidID == this.fluid.getID() )
|
||||
{
|
||||
NBTTagCompound ta = (NBTTagCompound) tagCompound;
|
||||
NBTTagCompound tb = is.tag;
|
||||
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 FluidStack getFluidStack()
|
||||
{
|
||||
FluidStack is = new FluidStack( fluid, (int) Math.min( Integer.MAX_VALUE, stackSize ) );
|
||||
if ( tagCompound != null )
|
||||
is.tag = tagCompound.getNBTTagCompoundCopy();
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAEFluidStack copy()
|
||||
{
|
||||
return new AEFluidStack( this );
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToNBT(NBTTagCompound i)
|
||||
{
|
||||
/*
|
||||
* Ugly Yes, but it saves a lot in the memory department.
|
||||
*/
|
||||
|
||||
NBTBase FluidName = i.getTag( "FluidName" );
|
||||
NBTBase Count = i.getTag( "Count" );
|
||||
// NBTBase Priority = i.getTag( "Priority" );
|
||||
NBTBase Cnt = i.getTag( "Cnt" );
|
||||
NBTBase Req = i.getTag( "Req" );
|
||||
NBTBase Craft = i.getTag( "Craft" );
|
||||
|
||||
if ( FluidName != null && FluidName instanceof NBTTagString )
|
||||
((NBTTagString) FluidName).data = (String) this.fluid.getName();
|
||||
else
|
||||
i.setString( "FluidName", (String) this.fluid.getName() );
|
||||
|
||||
// if ( Priority != null && Priority instanceof NBTTagInt )
|
||||
// ((NBTTagInt) Priority).data = this.priority;
|
||||
// else
|
||||
// i.setInteger( "Priority", this.priority );
|
||||
|
||||
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.stackSize );
|
||||
|
||||
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 ( tagCompound != null )
|
||||
i.setTag( "tag", (NBTTagCompound) tagCompound );
|
||||
else
|
||||
i.removeTag( "tag" );
|
||||
|
||||
}
|
||||
|
||||
public static IAEFluidStack loadFluidStackFromNBT(NBTTagCompound i)
|
||||
{
|
||||
ItemStack itemstack = ItemStack.loadItemStackFromNBT( i );
|
||||
if ( itemstack == null )
|
||||
return null;
|
||||
AEFluidStack aeis = AEFluidStack.create( itemstack );
|
||||
// aeis.priority = i.getInteger( "Priority" );
|
||||
aeis.stackSize = i.getLong( "Cnt" );
|
||||
aeis.setCountRequestable( i.getLong( "Req" ) );
|
||||
aeis.setCraftable( i.getBoolean( "Craft" ) );
|
||||
return aeis;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasTagCompound()
|
||||
{
|
||||
return tagCompound != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode()
|
||||
{
|
||||
return myHash;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(AEFluidStack b)
|
||||
{
|
||||
int diff = hashCode() - b.hashCode();
|
||||
return diff > 0 ? 1 : (diff < 0 ? -1 : 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
void writeIdentity(DataOutputStream i) throws IOException
|
||||
{
|
||||
byte[] name = fluid.getName().getBytes( "UTF-8" );
|
||||
i.writeByte( (byte) name.length );
|
||||
i.write( name );
|
||||
}
|
||||
|
||||
@Override
|
||||
void readNBT(DataOutputStream i) throws IOException
|
||||
{
|
||||
if ( hasTagCompound() )
|
||||
{
|
||||
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
|
||||
DataOutputStream data = new DataOutputStream( bytes );
|
||||
|
||||
CompressedStreamTools.write( (NBTTagCompound) getTagCompound(), data );
|
||||
|
||||
byte[] tagBytes = bytes.toByteArray();
|
||||
int size = tagBytes.length;
|
||||
|
||||
i.writeInt( size );
|
||||
i.write( tagBytes );
|
||||
}
|
||||
}
|
||||
|
||||
public static IAEFluidStack loadItemStackFromPacket(DataInputStream data) throws IOException
|
||||
{
|
||||
byte mask = data.readByte();
|
||||
// byte PriorityType = (byte) (mask & 0x03);
|
||||
byte StackType = (byte) ((mask & 0x0C) >> 2);
|
||||
byte CountReqType = (byte) ((mask & 0x30) >> 4);
|
||||
boolean isCraftable = (mask & 0x40) > 0;
|
||||
boolean hasTagCompound = (mask & 0x80) > 0;
|
||||
|
||||
// don't send this...
|
||||
NBTTagCompound d = new NBTTagCompound();
|
||||
|
||||
byte len2 = data.readByte();
|
||||
byte name[] = new byte[len2];
|
||||
data.read( name, 0, len2 );
|
||||
|
||||
d.setString( "FluidName", new String( name, "UTF-8" ) );
|
||||
d.setByte( "Count", (byte) 0 );
|
||||
|
||||
if ( hasTagCompound )
|
||||
{
|
||||
int len = data.readInt();
|
||||
|
||||
byte[] bd = new byte[len];
|
||||
data.readFully( bd );
|
||||
|
||||
DataInput di = ByteStreams.newDataInput( bd );
|
||||
d.setCompoundTag( "tag", CompressedStreamTools.read( di ) );
|
||||
}
|
||||
|
||||
// long priority = getPacketValue( PriorityType, data );
|
||||
long stackSize = getPacketValue( StackType, data );
|
||||
long countRequestable = getPacketValue( CountReqType, data );
|
||||
|
||||
FluidStack fluidStack = FluidStack.loadFluidStackFromNBT( d );
|
||||
if ( fluidStack == null )
|
||||
return null;
|
||||
|
||||
AEFluidStack aeis = AEFluidStack.create( fluidStack );
|
||||
// aeis.priority = (int) priority;
|
||||
aeis.stackSize = stackSize;
|
||||
aeis.setCountRequestable( countRequestable );
|
||||
aeis.setCraftable( isCraftable );
|
||||
return aeis;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Fluid getFluid()
|
||||
{
|
||||
return fluid;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAEFluidStack empty()
|
||||
{
|
||||
IAEFluidStack dup = copy();
|
||||
dup.reset();
|
||||
return dup;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean fuzzyComparison(Object st, FuzzyMode mode)
|
||||
{
|
||||
if ( st instanceof FluidStack )
|
||||
{
|
||||
return ((FluidStack) st).getFluid() == getFluid();
|
||||
}
|
||||
|
||||
if ( st instanceof IAEFluidStack )
|
||||
{
|
||||
return ((IAEFluidStack) st).getFluid() == getFluid();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import net.minecraft.item.Item;
|
||||
import appeng.api.storage.data.IAETagCompound;
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
|
||||
public class AEItemDef
|
||||
{
|
||||
|
||||
public int myHash;
|
||||
|
||||
public int def;
|
||||
|
||||
public Item item;
|
||||
public int damageValue;
|
||||
|
||||
public int dspDamage;
|
||||
public int maxDamage;
|
||||
|
||||
public IAETagCompound tagCompound;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public String displayName;
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public List tooltip;
|
||||
|
||||
public AEItemDef copy()
|
||||
{
|
||||
AEItemDef t = new AEItemDef();
|
||||
t.def = def;
|
||||
t.item = item;
|
||||
t.damageValue = damageValue;
|
||||
t.dspDamage = dspDamage;
|
||||
t.maxDamage = maxDamage;
|
||||
return t;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,499 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.DataInput;
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.List;
|
||||
|
||||
import net.minecraft.item.Item;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.CompressedStreamTools;
|
||||
import net.minecraft.nbt.NBTBase;
|
||||
import net.minecraft.nbt.NBTTagByte;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import net.minecraft.nbt.NBTTagLong;
|
||||
import net.minecraft.nbt.NBTTagShort;
|
||||
import appeng.api.config.FuzzyMode;
|
||||
import appeng.api.storage.data.IAEItemStack;
|
||||
import appeng.api.storage.data.IAETagCompound;
|
||||
import appeng.util.Platform;
|
||||
|
||||
import com.google.common.io.ByteStreams;
|
||||
|
||||
import cpw.mods.fml.relauncher.Side;
|
||||
import cpw.mods.fml.relauncher.SideOnly;
|
||||
|
||||
public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemStack, Comparable<AEItemStack>
|
||||
{
|
||||
|
||||
AEItemDef def;
|
||||
|
||||
@Override
|
||||
public void add(IAEItemStack option)
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
// if ( priority < ((AEItemStack) option).priority )
|
||||
// priority = ((AEItemStack) option).priority;
|
||||
|
||||
incStackSize( option.getStackSize() );
|
||||
setCountRequestable( getCountRequestable() + option.getCountRequestable() );
|
||||
setCraftable( isCraftable() || option.isCraftable() );
|
||||
}
|
||||
|
||||
private AEItemStack(AEItemStack is) {
|
||||
def = is.def;
|
||||
stackSize = is.stackSize;
|
||||
setCraftable( is.isCraftable() );
|
||||
setCountRequestable( is.getCountRequestable() );
|
||||
}
|
||||
|
||||
protected AEItemStack(ItemStack is) {
|
||||
if ( is == null )
|
||||
throw new RuntimeException( "Invalid Itemstack." );
|
||||
|
||||
def = new AEItemDef();
|
||||
def.item = is.getItem();
|
||||
|
||||
/*
|
||||
* Prevent an Item from changing the damage value on me... Either, this or a core mod.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Super Hacky.
|
||||
*
|
||||
* is.itemID = appeng.api.Materials.matQuartz.itemID; damageValue = is.getItemDamage(); is.itemID = itemID;
|
||||
*/
|
||||
|
||||
/*
|
||||
* Kinda Hacky
|
||||
*/
|
||||
def.damageValue = Item.blazeRod.getDamage( is );
|
||||
def.def = is.itemID << Platform.DEF_OFFSET | def.damageValue;
|
||||
|
||||
def.dspDamage = is.getItemDamageForDisplay();
|
||||
def.maxDamage = is.getMaxDamage();
|
||||
|
||||
def.tagCompound = (IAETagCompound) AESharedNBT.getSharedTagCompound( is );
|
||||
|
||||
stackSize = is.stackSize;
|
||||
setCraftable( false );
|
||||
setCountRequestable( 0 );
|
||||
|
||||
def.myHash = def.def ^ (def.tagCompound == null ? 0 : System.identityHashCode( def.tagCompound ));
|
||||
}
|
||||
|
||||
public static AEItemStack create(Object a)
|
||||
{
|
||||
if ( a == null )
|
||||
return null;
|
||||
if ( a instanceof IAEItemStack )
|
||||
((IAEItemStack) a).copy();
|
||||
if ( a instanceof ItemStack )
|
||||
return new AEItemStack( (ItemStack) a );
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Item getItem()
|
||||
{
|
||||
return def.item;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object ia)
|
||||
{
|
||||
if ( ia instanceof AEItemStack )
|
||||
{
|
||||
return ((AEItemStack) ia).def == def && def.tagCompound == ((AEItemStack) ia).def.tagCompound;
|
||||
}
|
||||
else if ( ia instanceof ItemStack )
|
||||
{
|
||||
ItemStack is = (ItemStack) ia;
|
||||
|
||||
if ( is.getItem() == def.item && is.getItemDamage() == this.def.damageValue )
|
||||
{
|
||||
NBTTagCompound ta = (NBTTagCompound) def.tagCompound;
|
||||
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 ItemStack getItemStack()
|
||||
{
|
||||
ItemStack is = new ItemStack( def.item, (int) Math.min( Integer.MAX_VALUE, stackSize ), def.damageValue );
|
||||
if ( def.tagCompound != null )
|
||||
is.setTagCompound( def.tagCompound.getNBTTagCompoundCopy() );
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAEItemStack copy()
|
||||
{
|
||||
return new AEItemStack( this );
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToNBT(NBTTagCompound i)
|
||||
{
|
||||
/*
|
||||
* Ugly Yes, but it saves a lot in the memory department.
|
||||
*/
|
||||
|
||||
NBTBase id = i.getTag( "id" );
|
||||
NBTBase Count = i.getTag( "Count" );
|
||||
// NBTBase Priority = i.getTag( "Priority" );
|
||||
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) this.def.item.itemID );
|
||||
|
||||
// if ( Priority != null && Priority instanceof NBTTagInt )
|
||||
// ((NBTTagInt) Priority).data = this.priority;
|
||||
// else
|
||||
// i.setInteger( "Priority", this.priority );
|
||||
|
||||
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.stackSize );
|
||||
|
||||
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.def.damageValue );
|
||||
|
||||
if ( def.tagCompound != null )
|
||||
i.setTag( "tag", (NBTTagCompound) def.tagCompound );
|
||||
else
|
||||
i.removeTag( "tag" );
|
||||
|
||||
}
|
||||
|
||||
public static IAEItemStack loadItemStackFromNBT(NBTTagCompound i)
|
||||
{
|
||||
ItemStack itemstack = ItemStack.loadItemStackFromNBT( i );
|
||||
if ( itemstack == null )
|
||||
return null;
|
||||
AEItemStack aeis = AEItemStack.create( itemstack );
|
||||
// aeis.priority = i.getInteger( "Priority" );
|
||||
aeis.stackSize = i.getLong( "Cnt" );
|
||||
aeis.setCountRequestable( i.getLong( "Req" ) );
|
||||
aeis.setCraftable( i.getBoolean( "Craft" ) );
|
||||
return aeis;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasTagCompound()
|
||||
{
|
||||
return def.tagCompound != null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode()
|
||||
{
|
||||
return def.myHash;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(AEItemStack b)
|
||||
{
|
||||
int id = def.item.itemID - b.def.item.itemID;
|
||||
int dv = def.damageValue - b.def.damageValue;
|
||||
int dspv = def.dspDamage - b.def.dspDamage;
|
||||
|
||||
return id == 0 ? (dv == 0 ? (dspv == 0 ? ((def.tagCompound == null ? 0 : def.tagCompound.hashCode()) - (b.def.tagCompound == null ? 0
|
||||
: b.def.tagCompound.hashCode())) : dspv) : dv) : id;
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public List getToolTip()
|
||||
{
|
||||
if ( def.tooltip != null )
|
||||
return def.tooltip;
|
||||
|
||||
return def.tooltip = Platform.getTooltip( getItemStack() );
|
||||
}
|
||||
|
||||
@SideOnly(Side.CLIENT)
|
||||
public String getDisplayName()
|
||||
{
|
||||
if ( def.displayName != null )
|
||||
return def.displayName;
|
||||
|
||||
return def.displayName = Platform.getItemDisplayName( getItemStack() );
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAEItemStack empty()
|
||||
{
|
||||
IAEItemStack dup = copy();
|
||||
dup.reset();
|
||||
return dup;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getItemDamage()
|
||||
{
|
||||
return def.damageValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
void writeIdentity(DataOutputStream i) throws IOException
|
||||
{
|
||||
i.writeShort( def.item.itemID );
|
||||
i.writeShort( getItemDamage() );
|
||||
}
|
||||
|
||||
@Override
|
||||
void readNBT(DataOutputStream i) throws IOException
|
||||
{
|
||||
if ( hasTagCompound() )
|
||||
{
|
||||
ByteArrayOutputStream bytes = new ByteArrayOutputStream();
|
||||
DataOutputStream data = new DataOutputStream( bytes );
|
||||
|
||||
CompressedStreamTools.write( (NBTTagCompound) getTagCompound(), data );
|
||||
|
||||
byte[] tagBytes = bytes.toByteArray();
|
||||
int size = tagBytes.length;
|
||||
|
||||
i.writeInt( size );
|
||||
i.write( tagBytes );
|
||||
}
|
||||
}
|
||||
|
||||
public static IAEItemStack loadItemStackFromPacket(DataInputStream data) throws IOException
|
||||
{
|
||||
byte mask = data.readByte();
|
||||
// byte PriorityType = (byte) (mask & 0x03);
|
||||
byte StackType = (byte) ((mask & 0x0C) >> 2);
|
||||
byte CountReqType = (byte) ((mask & 0x30) >> 4);
|
||||
boolean isCraftable = (mask & 0x40) > 0;
|
||||
boolean hasTagCompound = (mask & 0x80) > 0;
|
||||
|
||||
// don't send this...
|
||||
NBTTagCompound d = new NBTTagCompound();
|
||||
|
||||
d.setShort( "id", data.readShort() );
|
||||
d.setShort( "Damage", data.readShort() );
|
||||
d.setByte( "Count", (byte) 0 );
|
||||
|
||||
if ( hasTagCompound )
|
||||
{
|
||||
int len = data.readInt();
|
||||
|
||||
byte[] bd = new byte[len];
|
||||
data.readFully( bd );
|
||||
|
||||
DataInput di = ByteStreams.newDataInput( bd );
|
||||
d.setCompoundTag( "tag", CompressedStreamTools.read( di ) );
|
||||
}
|
||||
|
||||
// long priority = getPacketValue( PriorityType, data );
|
||||
long stackSize = getPacketValue( StackType, data );
|
||||
long countRequestable = getPacketValue( CountReqType, data );
|
||||
|
||||
ItemStack itemstack = ItemStack.loadItemStackFromNBT( d );
|
||||
if ( itemstack == null )
|
||||
return null;
|
||||
|
||||
AEItemStack aeis = AEItemStack.create( itemstack );
|
||||
// aeis.priority = (int) priority;
|
||||
aeis.stackSize = stackSize;
|
||||
aeis.setCountRequestable( countRequestable );
|
||||
aeis.setCraftable( isCraftable );
|
||||
return aeis;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean sameOre(IAEItemStack is)
|
||||
{
|
||||
return OreHelper.instance.sameOre( this, is );
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean fuzzyComparison(Object st, FuzzyMode Mode)
|
||||
{
|
||||
if ( st instanceof IAEItemStack )
|
||||
{
|
||||
IAEItemStack o = (IAEItemStack) st;
|
||||
|
||||
if ( sameOre( o ) )
|
||||
return true;
|
||||
|
||||
if ( o.getItem() == getItem() )
|
||||
{
|
||||
if ( def.item.isDamageable() )
|
||||
{
|
||||
ItemStack a = getItemStack();
|
||||
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
|
||||
{
|
||||
float APercentDamaged = 1.0f - (float) a.getItemDamageForDisplay() / (float) a.getMaxDamage();
|
||||
float BPercentDamaged = 1.0f - (float) b.getItemDamageForDisplay() / (float) b.getMaxDamage();
|
||||
|
||||
return (APercentDamaged > Mode.breakPoint) == (BPercentDamaged > Mode.breakPoint);
|
||||
}
|
||||
}
|
||||
catch (Throwable e)
|
||||
{
|
||||
if ( Mode == FuzzyMode.IGNORE_ALL )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if ( Mode == FuzzyMode.PERCENT_99 )
|
||||
{
|
||||
return (a.getItemDamage() > 1) == (b.getItemDamage() > 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
float APercentDamaged = (float) a.getItemDamage() / (float) a.getMaxDamage();
|
||||
float BPercentDamaged = (float) b.getItemDamage() / (float) b.getMaxDamage();
|
||||
|
||||
return (APercentDamaged > Mode.breakPoint) == (BPercentDamaged > Mode.breakPoint);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this.getItemDamage() == o.getItemDamage();
|
||||
}
|
||||
}
|
||||
|
||||
if ( st instanceof ItemStack )
|
||||
{
|
||||
ItemStack o = (ItemStack) st;
|
||||
|
||||
OreHelper.instance.sameOre( this, o );
|
||||
|
||||
if ( o.getItem() == getItem() )
|
||||
{
|
||||
if ( def.item.isDamageable() )
|
||||
{
|
||||
ItemStack a = getItemStack();
|
||||
ItemStack b = o;
|
||||
|
||||
try
|
||||
{
|
||||
if ( Mode == FuzzyMode.IGNORE_ALL )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if ( Mode == FuzzyMode.PERCENT_99 )
|
||||
{
|
||||
return (a.getItemDamageForDisplay() > 1) == (b.getItemDamageForDisplay() > 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
float APercentDamaged = 1.0f - (float) a.getItemDamageForDisplay() / (float) a.getMaxDamage();
|
||||
float BPercentDamaged = 1.0f - (float) b.getItemDamageForDisplay() / (float) b.getMaxDamage();
|
||||
|
||||
return (APercentDamaged > Mode.breakPoint) == (BPercentDamaged > Mode.breakPoint);
|
||||
}
|
||||
}
|
||||
catch (Throwable e)
|
||||
{
|
||||
if ( Mode == FuzzyMode.IGNORE_ALL )
|
||||
{
|
||||
return true;
|
||||
}
|
||||
else if ( Mode == FuzzyMode.PERCENT_99 )
|
||||
{
|
||||
return (a.getItemDamage() > 1) == (b.getItemDamage() > 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
float APercentDamaged = (float) a.getItemDamage() / (float) a.getMaxDamage();
|
||||
float BPercentDamaged = (float) b.getItemDamage() / (float) b.getMaxDamage();
|
||||
|
||||
return (APercentDamaged > Mode.breakPoint) == (BPercentDamaged > Mode.breakPoint);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return this.getItemDamage() == o.getItemDamage();
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public IAEItemStack getLow(FuzzyMode fuzzy)
|
||||
{
|
||||
AEItemStack bottom = new AEItemStack( this );
|
||||
bottom.def = bottom.def.copy();
|
||||
|
||||
int low = fuzzy.calculateBreakPoint( def.maxDamage );
|
||||
bottom.def.dspDamage = low < def.dspDamage ? low : 0;
|
||||
|
||||
return bottom;
|
||||
}
|
||||
|
||||
public IAEItemStack getHigh(FuzzyMode fuzzy)
|
||||
{
|
||||
AEItemStack top = new AEItemStack( this );
|
||||
top.def = top.def.copy();
|
||||
|
||||
int high = fuzzy.calculateBreakPoint( def.maxDamage );
|
||||
top.def.dspDamage = high > def.dspDamage ? high : def.maxDamage;
|
||||
|
||||
return top;
|
||||
}
|
||||
|
||||
@Override
|
||||
public IAETagCompound getTagCompound()
|
||||
{
|
||||
return def.tagCompound;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,172 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.lang.ref.WeakReference;
|
||||
import java.util.Iterator;
|
||||
import java.util.WeakHashMap;
|
||||
|
||||
import net.minecraft.item.ItemStack;
|
||||
import net.minecraft.nbt.NBTBase;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
import appeng.api.AEApi;
|
||||
import appeng.api.features.IItemComparison;
|
||||
import appeng.api.storage.data.IAETagCompound;
|
||||
import appeng.util.Platform;
|
||||
|
||||
/*
|
||||
* this is used for the shared NBT Cache.
|
||||
*/
|
||||
public class AESharedNBT extends NBTTagCompound implements IAETagCompound
|
||||
{
|
||||
|
||||
private int itemid, meta, hash;
|
||||
public SharedSearchObject sso;
|
||||
private IItemComparison comp;
|
||||
|
||||
@Override
|
||||
public IItemComparison getSpecialComparison()
|
||||
{
|
||||
return comp;
|
||||
}
|
||||
|
||||
private AESharedNBT(int itemID, int damageValue, String name) {
|
||||
super( name );
|
||||
itemid = itemID;
|
||||
meta = damageValue;
|
||||
}
|
||||
|
||||
@Override
|
||||
public NBTTagCompound getNBTTagCompoundCopy()
|
||||
{
|
||||
return (NBTTagCompound) copy();
|
||||
}
|
||||
|
||||
public static AESharedNBT createFromCompound(int itemID, int damageValue, NBTTagCompound c)
|
||||
{
|
||||
AESharedNBT x = new AESharedNBT( itemID, damageValue, c.getName() );
|
||||
|
||||
Iterator var2 = c.getTags().iterator();
|
||||
|
||||
while (var2.hasNext())
|
||||
{
|
||||
NBTBase tag = (NBTBase) var2.next();
|
||||
x.setTag( tag.getName(), (NBTBase) tag.copy() );
|
||||
}
|
||||
|
||||
x.hash = Platform.NBTOrderlessHash( c );
|
||||
|
||||
ItemStack isc = new ItemStack( itemID, 1, damageValue );
|
||||
isc.setTagCompound( c );
|
||||
x.comp = AEApi.instance().registries().specialComparson().getSpecialComparion( isc );
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object par1Obj)
|
||||
{
|
||||
if ( par1Obj instanceof AESharedNBT )
|
||||
return this == par1Obj;
|
||||
return super.equals( par1Obj );
|
||||
}
|
||||
|
||||
public boolean matches(int itemid2, int meta2, int orderlessHash)
|
||||
{
|
||||
return itemid2 == itemid && meta == meta2 && hash == orderlessHash;
|
||||
}
|
||||
|
||||
public boolean comparePreciseWithRegistry(AESharedNBT tagCompound)
|
||||
{
|
||||
if ( this == tagCompound )
|
||||
return true;
|
||||
|
||||
if ( comp != null && tagCompound.comp != null )
|
||||
{
|
||||
return comp.sameAsPrecise( tagCompound.comp );
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean compareFuzzyWithRegistry(AESharedNBT tagCompound)
|
||||
{
|
||||
if ( this == tagCompound )
|
||||
return true;
|
||||
if ( tagCompound == null )
|
||||
return false;
|
||||
|
||||
if ( comp == tagCompound.comp )
|
||||
return true;
|
||||
|
||||
if ( comp != null )
|
||||
{
|
||||
return comp.sameAsFuzzy( tagCompound.comp );
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Shared Tag Compound Cache.
|
||||
*/
|
||||
private static WeakHashMap<SharedSearchObject, WeakReference<SharedSearchObject>> sharedTagCompounts = new WeakHashMap();
|
||||
|
||||
/*
|
||||
* Debug purposes.
|
||||
*/
|
||||
public static int sharedTagLoad()
|
||||
{
|
||||
return sharedTagCompounts.size();
|
||||
}
|
||||
|
||||
/*
|
||||
* returns true if the compound is part of the shared compound system ( and can thus be compared directly ).
|
||||
*/
|
||||
public static boolean isShared(NBTTagCompound ta)
|
||||
{
|
||||
return ta instanceof AESharedNBT;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns an NBT Compound that is used for accelerating comparisons.
|
||||
*/
|
||||
synchronized public static NBTTagCompound getSharedTagCompound(ItemStack s)
|
||||
{
|
||||
NBTTagCompound tagCompound = s.getTagCompound();
|
||||
if ( tagCompound == null )
|
||||
return null;
|
||||
if ( tagCompound.hasNoTags() )
|
||||
return null;
|
||||
|
||||
int itemid = s.itemID;
|
||||
int meta = -1;
|
||||
if ( s.itemID != 0 && s.isItemStackDamageable() && s.getHasSubtypes() )
|
||||
meta = s.getItemDamage();
|
||||
|
||||
if ( isShared( tagCompound ) )
|
||||
return tagCompound;
|
||||
|
||||
SharedSearchObject sso = new SharedSearchObject( itemid, meta, tagCompound );
|
||||
|
||||
WeakReference<SharedSearchObject> c = sharedTagCompounts.get( sso );
|
||||
if ( c != null )
|
||||
{
|
||||
SharedSearchObject cg = c.get();
|
||||
if ( cg != null )
|
||||
return cg.shared; // I don't think I really need to check this
|
||||
// as its already certain to exist..
|
||||
}
|
||||
|
||||
AESharedNBT clone = AESharedNBT.createFromCompound( itemid, meta, tagCompound );
|
||||
sso.compound = (NBTTagCompound) sso.compound.copy(); // prevent
|
||||
// modification
|
||||
// of data based
|
||||
// on original
|
||||
// item.
|
||||
sso.shared = clone;
|
||||
clone.sso = sso;
|
||||
|
||||
sharedTagCompounts.put( sso, new WeakReference<SharedSearchObject>( sso ) );
|
||||
return clone;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.io.DataInputStream;
|
||||
import java.io.DataOutputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
import appeng.api.storage.data.IAEStack;
|
||||
|
||||
public abstract class AEStack<StackType extends IAEStack> implements IAEStack<StackType>
|
||||
{
|
||||
|
||||
protected boolean isCraftable;
|
||||
protected long stackSize;
|
||||
protected long countRequestable;
|
||||
|
||||
@Override
|
||||
public boolean isMeaninful()
|
||||
{
|
||||
return stackSize != 0 || getCountRequestable() > 0 || isCraftable();
|
||||
}
|
||||
|
||||
@Override
|
||||
public StackType reset()
|
||||
{
|
||||
stackSize = 0;
|
||||
// priority = Integer.MIN_VALUE;
|
||||
setCountRequestable( 0 );
|
||||
setCraftable( false );
|
||||
return (StackType) this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getStackSize()
|
||||
{
|
||||
return stackSize;
|
||||
}
|
||||
|
||||
@Override
|
||||
public StackType setStackSize(long ss)
|
||||
{
|
||||
stackSize = ss;
|
||||
return (StackType) this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public long getCountRequestable()
|
||||
{
|
||||
return countRequestable;
|
||||
}
|
||||
|
||||
@Override
|
||||
public StackType setCountRequestable(long countRequestable)
|
||||
{
|
||||
this.countRequestable = countRequestable;
|
||||
return (StackType) this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isCraftable()
|
||||
{
|
||||
return isCraftable;
|
||||
}
|
||||
|
||||
@Override
|
||||
public StackType setCraftable(boolean isCraftable)
|
||||
{
|
||||
this.isCraftable = isCraftable;
|
||||
return (StackType) this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void decStackSize(long i)
|
||||
{
|
||||
stackSize -= i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void incStackSize(long i)
|
||||
{
|
||||
stackSize += i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void decCountRequestable(long i)
|
||||
{
|
||||
countRequestable -= i;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void incCountRequestable(long i)
|
||||
{
|
||||
countRequestable += i;
|
||||
}
|
||||
|
||||
void putPacketValue(DataOutputStream tag, long num) throws IOException
|
||||
{
|
||||
if ( num <= 255 )
|
||||
tag.writeByte( (byte) (num + (long) Byte.MIN_VALUE) );
|
||||
else if ( num <= 65535 )
|
||||
tag.writeShort( (short) (num + (long) Short.MIN_VALUE) );
|
||||
else if ( num <= 4294967295L )
|
||||
tag.writeInt( (int) (num + (long) Integer.MIN_VALUE) );
|
||||
else
|
||||
tag.writeLong( num );
|
||||
}
|
||||
|
||||
static long getPacketValue(byte type, DataInputStream tag) throws IOException
|
||||
{
|
||||
if ( type == 0 )
|
||||
{
|
||||
long l = tag.readByte();
|
||||
l -= (long) Byte.MIN_VALUE;
|
||||
return l;
|
||||
}
|
||||
else if ( type == 1 )
|
||||
{
|
||||
long l = tag.readShort();
|
||||
l -= (long) Short.MIN_VALUE;
|
||||
return l;
|
||||
}
|
||||
else if ( type == 2 )
|
||||
{
|
||||
long l = tag.readInt();
|
||||
l -= (long) Integer.MIN_VALUE;
|
||||
return l;
|
||||
}
|
||||
|
||||
return tag.readLong();
|
||||
}
|
||||
|
||||
byte getType(long num)
|
||||
{
|
||||
if ( num <= 255 )
|
||||
return 0;
|
||||
else if ( num <= 65535 )
|
||||
return 1;
|
||||
else if ( num <= 4294967295L )
|
||||
return 2;
|
||||
else
|
||||
return 3;
|
||||
}
|
||||
|
||||
abstract void writeIdentity(DataOutputStream i) throws IOException;
|
||||
|
||||
abstract void readNBT(DataOutputStream i) throws IOException;
|
||||
|
||||
abstract boolean hasTagCompound();
|
||||
|
||||
@Override
|
||||
public void writeToPacket(DataOutputStream i) throws IOException
|
||||
{
|
||||
byte mask = (byte) (getType( 0 ) | (getType( stackSize ) << 2) | (getType( getCountRequestable() ) << 4) | ((byte) (isCraftable ? 1 : 0) << 6) | (hasTagCompound() ? 1
|
||||
: 0) << 7);
|
||||
|
||||
i.writeByte( mask );
|
||||
writeIdentity( i );
|
||||
|
||||
readNBT( i );
|
||||
|
||||
// putPacketValue( i, priority );
|
||||
putPacketValue( i, stackSize );
|
||||
putPacketValue( i, getCountRequestable() );
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.TreeMap;
|
||||
|
||||
import appeng.api.config.FuzzyMode;
|
||||
import appeng.api.storage.data.IAEFluidStack;
|
||||
import appeng.api.storage.data.IAEItemStack;
|
||||
import appeng.api.storage.data.IAEStack;
|
||||
import appeng.api.storage.data.IItemList;
|
||||
|
||||
public final class ItemList<StackType extends IAEStack> implements IItemList<StackType>
|
||||
{
|
||||
|
||||
private final TreeMap<StackType, StackType> records = new TreeMap();
|
||||
// private int currentPriority = Integer.MIN_VALUE;
|
||||
|
||||
int iteration = Integer.MIN_VALUE;
|
||||
public Throwable stacktrace;
|
||||
|
||||
@Override
|
||||
synchronized public void add(StackType option)
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
StackType st = records.get( option );
|
||||
|
||||
if ( st != null )
|
||||
{
|
||||
// st.setPriority( currentPriority );
|
||||
st.add( option );
|
||||
return;
|
||||
}
|
||||
|
||||
StackType opt = (StackType) option.copy();
|
||||
// opt.setPriority( currentPriority );
|
||||
records.put( opt, opt );
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public void addStorage(StackType option) // adds a stack as
|
||||
// stored.
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
StackType st = records.get( option );
|
||||
|
||||
if ( st != null )
|
||||
{
|
||||
// st.setPriority( currentPriority );
|
||||
st.incStackSize( option.getStackSize() );
|
||||
return;
|
||||
}
|
||||
|
||||
StackType opt = (StackType) option.copy();
|
||||
// opt.setPriority( currentPriority );
|
||||
records.put( opt, opt );
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public void addCrafting(StackType option) // adds a stack as
|
||||
// craftable.
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
StackType st = records.get( option );
|
||||
|
||||
if ( st != null )
|
||||
{
|
||||
// st.setPriority( currentPriority );
|
||||
st.setCraftable( true );
|
||||
return;
|
||||
}
|
||||
|
||||
StackType opt = (StackType) option.copy();
|
||||
// opt.setPriority( currentPriority );
|
||||
opt.setStackSize( 0 );
|
||||
opt.setCraftable( true );
|
||||
|
||||
records.put( opt, opt );
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public void addRequestable(StackType option) // adds a stack
|
||||
// as
|
||||
// requestable.
|
||||
{
|
||||
if ( option == null )
|
||||
return;
|
||||
|
||||
StackType st = records.get( option );
|
||||
|
||||
if ( st != null )
|
||||
{
|
||||
// st.setPriority( currentPriority );
|
||||
((IAEItemStack) st).setCountRequestable( ((IAEItemStack) st).getCountRequestable() + ((IAEItemStack) option).getCountRequestable() );
|
||||
return;
|
||||
}
|
||||
|
||||
StackType opt = (StackType) option.copy();
|
||||
// opt.setPriority( currentPriority );
|
||||
opt.setStackSize( 0 );
|
||||
opt.setCraftable( false );
|
||||
opt.setCountRequestable( opt.getCountRequestable() );
|
||||
|
||||
records.put( opt, opt );
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public StackType getFirstItem()
|
||||
{
|
||||
Iterator<StackType> i = this.iterator();
|
||||
while (i.hasNext())
|
||||
return i.next();
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public void resetStatus()
|
||||
{
|
||||
for (StackType i : this)
|
||||
i.reset();
|
||||
}
|
||||
|
||||
/*
|
||||
* synchronized public void clean() { Iterator<StackType> i = iterator(); while (i.hasNext()) { StackType AEI =
|
||||
* i.next(); if ( !AEI.isMeaninful() ) i.remove(); } }
|
||||
*/
|
||||
|
||||
@Override
|
||||
synchronized public Iterator iterator()
|
||||
{
|
||||
return new MeanfulIterator( records.values().iterator() );
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public StackType findPrecise(StackType i)
|
||||
{
|
||||
if ( i == null )
|
||||
return null;
|
||||
|
||||
StackType is = records.get( i );
|
||||
if ( is != null )
|
||||
{
|
||||
return is;
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
synchronized public int size()
|
||||
{
|
||||
return records.values().size();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isEmpty()
|
||||
{
|
||||
return records.isEmpty();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<StackType> findFuzzy(StackType filter, FuzzyMode fuzzy)
|
||||
{
|
||||
if ( filter instanceof IAEFluidStack )
|
||||
return filter.equals( this ) ? (List<StackType>) Arrays.asList( new IAEFluidStack[] { (IAEFluidStack) filter } ) : (List<StackType>) Arrays
|
||||
.asList( new IAEFluidStack[] {} );
|
||||
|
||||
AEItemStack ais = (AEItemStack) filter;
|
||||
|
||||
if ( OreHelper.instance.isOre( ais ) )
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
StackType low = (StackType) ais.getLow( fuzzy );
|
||||
StackType high = (StackType) ais.getHigh( fuzzy );
|
||||
return records.subMap( low, high ).values();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import java.util.Iterator;
|
||||
|
||||
import appeng.api.storage.data.IAEStack;
|
||||
|
||||
public class MeanfulIterator<StackType extends IAEStack> implements Iterator
|
||||
{
|
||||
|
||||
final Iterator<StackType> parent;
|
||||
private StackType next;
|
||||
|
||||
public MeanfulIterator(Iterator<StackType> iterator) {
|
||||
parent = iterator;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext()
|
||||
{
|
||||
while (parent.hasNext())
|
||||
{
|
||||
next = parent.next();
|
||||
if ( next.isMeaninful() )
|
||||
return true;
|
||||
else
|
||||
parent.remove(); // self cleaning :3
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Object next()
|
||||
{
|
||||
return next;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove()
|
||||
{
|
||||
parent.remove();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import net.minecraft.item.ItemStack;
|
||||
import appeng.api.storage.data.IAEItemStack;
|
||||
|
||||
public class OreHelper
|
||||
{
|
||||
|
||||
public static OreHelper instance;
|
||||
|
||||
public boolean isOre(IAEItemStack is)
|
||||
{
|
||||
// TODO Auto-generated method stub
|
||||
return false;
|
||||
}
|
||||
|
||||
public boolean sameOre(AEItemStack aeItemStack, IAEItemStack is)
|
||||
{
|
||||
// TODO Auto-generated method stub
|
||||
return false;
|
||||
}
|
||||
|
||||
public void sameOre(AEItemStack aeItemStack, ItemStack o)
|
||||
{
|
||||
// TODO Auto-generated method stub
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package appeng.util.item;
|
||||
|
||||
import appeng.util.Platform;
|
||||
import net.minecraft.nbt.NBTTagCompound;
|
||||
|
||||
public class SharedSearchObject
|
||||
{
|
||||
|
||||
int def;
|
||||
int hash;
|
||||
NBTTagCompound compound;
|
||||
public AESharedNBT shared;
|
||||
|
||||
public SharedSearchObject(int itemID, int damageValue, NBTTagCompound tagCompound) {
|
||||
def = (damageValue << Platform.DEF_OFFSET) | itemID;
|
||||
hash = Platform.NBTOrderlessHash( tagCompound );
|
||||
compound = tagCompound;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj)
|
||||
{
|
||||
if ( obj == null )
|
||||
return false;
|
||||
SharedSearchObject b = (SharedSearchObject) obj;
|
||||
if ( def == b.def && hash == b.hash )
|
||||
{
|
||||
return Platform.NBTEqualityTest( compound, b.compound );
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode()
|
||||
{
|
||||
return def ^ hash;
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user