mirror of
https://github.com/Thorfusion/Mekanism-Community-Edition.git
synced 2026-11-22 12:59:41 +00:00
495 lines
10 KiB
Java
495 lines
10 KiB
Java
package mekanism.common.tile;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
import mekanism.api.Coord4D;
|
|
import mekanism.api.IFilterAccess;
|
|
import mekanism.api.Range4D;
|
|
import mekanism.api.infuse.InfuseRegistry;
|
|
import mekanism.common.HashList;
|
|
import mekanism.common.Mekanism;
|
|
import mekanism.common.MekanismItems;
|
|
import mekanism.common.OreDictCache;
|
|
import mekanism.common.PacketHandler;
|
|
import mekanism.common.base.IRedstoneControl;
|
|
import mekanism.common.base.ISustainedData;
|
|
import mekanism.common.block.BlockMachine.MachineType;
|
|
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
|
|
import mekanism.common.recipe.RecipeHandler;
|
|
import mekanism.common.recipe.RecipeHandler.Recipe;
|
|
import mekanism.common.recipe.inputs.InfusionInput;
|
|
import mekanism.common.util.ChargeUtils;
|
|
import mekanism.common.util.InventoryUtils;
|
|
import mekanism.common.util.MekanismUtils;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraftforge.common.util.Constants.NBT;
|
|
import net.minecraftforge.oredict.OreDictionary;
|
|
|
|
public class TileEntityOredictionificator extends TileEntityContainerBlock implements IRedstoneControl, IFilterAccess, ISustainedData
|
|
{
|
|
public static final int MAX_LENGTH = 24;
|
|
|
|
public HashList<OredictionificatorFilter> filters = new HashList<OredictionificatorFilter>();
|
|
|
|
public static List<String> possibleFilters = Arrays.asList("ingot", "ore", "dust", "nugget");
|
|
|
|
public RedstoneControl controlType = RedstoneControl.DISABLED;
|
|
|
|
public boolean didProcess;
|
|
|
|
public TileEntityOredictionificator()
|
|
{
|
|
super(MachineType.OREDICTIONIFICATOR.name);
|
|
|
|
inventory = new ItemStack[2];
|
|
doAutoSync = false;
|
|
}
|
|
|
|
@Override
|
|
public void onUpdate()
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
if(playersUsing.size() > 0)
|
|
{
|
|
for(EntityPlayer player : playersUsing)
|
|
{
|
|
Mekanism.packetHandler.sendTo(new TileEntityMessage(Coord4D.get(this), getGenericPacket(new ArrayList())), (EntityPlayerMP)player);
|
|
}
|
|
}
|
|
|
|
didProcess = false;
|
|
|
|
if(inventory[0] != null && getValidName(inventory[0]) != null)
|
|
{
|
|
ItemStack result = getResult(inventory[0]);
|
|
|
|
if(result != null)
|
|
{
|
|
if(inventory[1] == null)
|
|
{
|
|
inventory[0].stackSize--;
|
|
|
|
if(inventory[0].stackSize <= 0)
|
|
{
|
|
inventory[0] = null;
|
|
}
|
|
|
|
inventory[1] = result;
|
|
didProcess = true;
|
|
}
|
|
else if(inventory[1].isItemEqual(result) && inventory[1].stackSize < inventory[1].getMaxStackSize())
|
|
{
|
|
inventory[0].stackSize--;
|
|
|
|
if(inventory[0].stackSize <= 0)
|
|
{
|
|
inventory[0] = null;
|
|
}
|
|
|
|
inventory[1].stackSize++;
|
|
didProcess = true;
|
|
}
|
|
|
|
markDirty();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public String getValidName(ItemStack stack)
|
|
{
|
|
List<String> def = OreDictCache.getOreDictName(stack);
|
|
|
|
for(String s : def)
|
|
{
|
|
for(String pre : possibleFilters)
|
|
{
|
|
if(s.startsWith(pre))
|
|
{
|
|
return s;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public ItemStack getResult(ItemStack stack)
|
|
{
|
|
String s = getValidName(stack);
|
|
|
|
if(s == null)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
List<ItemStack> ores = OreDictionary.getOres(s);
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
if(filter.filter.equals(s))
|
|
{
|
|
if(ores.size()-1 >= filter.index)
|
|
{
|
|
return MekanismUtils.size(ores.get(filter.index), 1);
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public int[] getAccessibleSlotsFromSide(int side)
|
|
{
|
|
if(side == MekanismUtils.getLeft(facing).ordinal())
|
|
{
|
|
return new int[] {0};
|
|
}
|
|
else if(side == MekanismUtils.getRight(facing).ordinal())
|
|
{
|
|
return new int[] {1};
|
|
}
|
|
else {
|
|
return InventoryUtils.EMPTY;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean canExtractItem(int slotID, ItemStack itemstack, int side)
|
|
{
|
|
return slotID == 1;
|
|
}
|
|
|
|
@Override
|
|
public boolean isItemValidForSlot(int slotID, ItemStack itemstack)
|
|
{
|
|
if(slotID == 0)
|
|
{
|
|
return getResult(itemstack) != null;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.writeToNBT(nbtTags);
|
|
|
|
nbtTags.setInteger("controlType", controlType.ordinal());
|
|
|
|
NBTTagList filterTags = new NBTTagList();
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
NBTTagCompound tagCompound = new NBTTagCompound();
|
|
filter.write(tagCompound);
|
|
filterTags.appendTag(tagCompound);
|
|
}
|
|
|
|
if(filterTags.tagCount() != 0)
|
|
{
|
|
nbtTags.setTag("filters", filterTags);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound nbtTags)
|
|
{
|
|
super.readFromNBT(nbtTags);
|
|
|
|
controlType = RedstoneControl.values()[nbtTags.getInteger("controlType")];
|
|
|
|
if(nbtTags.hasKey("filters"))
|
|
{
|
|
NBTTagList tagList = nbtTags.getTagList("filters", NBT.TAG_COMPOUND);
|
|
|
|
for(int i = 0; i < tagList.tagCount(); i++)
|
|
{
|
|
filters.add(OredictionificatorFilter.readFromNBT((NBTTagCompound)tagList.getCompoundTagAt(i)));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void handlePacketData(ByteBuf dataStream)
|
|
{
|
|
super.handlePacketData(dataStream);
|
|
|
|
int type = dataStream.readInt();
|
|
|
|
if(type == 0)
|
|
{
|
|
controlType = RedstoneControl.values()[dataStream.readInt()];
|
|
didProcess = dataStream.readBoolean();
|
|
|
|
filters.clear();
|
|
|
|
int amount = dataStream.readInt();
|
|
|
|
for(int i = 0; i < amount; i++)
|
|
{
|
|
filters.add(OredictionificatorFilter.readFromPacket(dataStream));
|
|
}
|
|
}
|
|
else if(type == 1)
|
|
{
|
|
controlType = RedstoneControl.values()[dataStream.readInt()];
|
|
didProcess = dataStream.readBoolean();
|
|
}
|
|
else if(type == 2)
|
|
{
|
|
filters.clear();
|
|
|
|
int amount = dataStream.readInt();
|
|
|
|
for(int i = 0; i < amount; i++)
|
|
{
|
|
filters.add(OredictionificatorFilter.readFromPacket(dataStream));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public ArrayList getNetworkedData(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
data.add(0);
|
|
|
|
data.add(controlType.ordinal());
|
|
data.add(didProcess);
|
|
|
|
data.add(filters.size());
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
filter.write(data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public ArrayList getGenericPacket(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
data.add(1);
|
|
|
|
data.add(controlType.ordinal());
|
|
data.add(didProcess);
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
public ArrayList getFilterPacket(ArrayList data)
|
|
{
|
|
super.getNetworkedData(data);
|
|
|
|
data.add(2);
|
|
|
|
data.add(filters.size());
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
filter.write(data);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
@Override
|
|
public void openInventory()
|
|
{
|
|
if(!worldObj.isRemote)
|
|
{
|
|
Mekanism.packetHandler.sendToReceivers(new TileEntityMessage(Coord4D.get(this), getFilterPacket(new ArrayList())), new Range4D(Coord4D.get(this)));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public NBTTagCompound getFilterData(NBTTagCompound nbtTags)
|
|
{
|
|
nbtTags.setInteger("controlType", controlType.ordinal());
|
|
|
|
NBTTagList filterTags = new NBTTagList();
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
NBTTagCompound tagCompound = new NBTTagCompound();
|
|
filter.write(tagCompound);
|
|
filterTags.appendTag(tagCompound);
|
|
}
|
|
|
|
if(filterTags.tagCount() != 0)
|
|
{
|
|
nbtTags.setTag("filters", filterTags);
|
|
}
|
|
|
|
return nbtTags;
|
|
}
|
|
|
|
@Override
|
|
public void setFilterData(NBTTagCompound nbtTags)
|
|
{
|
|
controlType = RedstoneControl.values()[nbtTags.getInteger("controlType")];
|
|
|
|
if(nbtTags.hasKey("filters"))
|
|
{
|
|
NBTTagList tagList = nbtTags.getTagList("filters", NBT.TAG_COMPOUND);
|
|
|
|
for(int i = 0; i < tagList.tagCount(); i++)
|
|
{
|
|
filters.add(OredictionificatorFilter.readFromNBT((NBTTagCompound)tagList.getCompoundTagAt(i)));
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String getDataType()
|
|
{
|
|
return "tooltip.filterCard.oredictionificator";
|
|
}
|
|
|
|
@Override
|
|
public void writeSustainedData(ItemStack itemStack)
|
|
{
|
|
itemStack.stackTagCompound.setBoolean("hasOredictionificatorConfig", true);
|
|
|
|
NBTTagList filterTags = new NBTTagList();
|
|
|
|
for(OredictionificatorFilter filter : filters)
|
|
{
|
|
NBTTagCompound tagCompound = new NBTTagCompound();
|
|
filter.write(tagCompound);
|
|
filterTags.appendTag(tagCompound);
|
|
}
|
|
|
|
if(filterTags.tagCount() != 0)
|
|
{
|
|
itemStack.stackTagCompound.setTag("filters", filterTags);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void readSustainedData(ItemStack itemStack)
|
|
{
|
|
if(itemStack.stackTagCompound.hasKey("hasOredictionificatorConfig"))
|
|
{
|
|
if(itemStack.stackTagCompound.hasKey("filters"))
|
|
{
|
|
NBTTagList tagList = itemStack.stackTagCompound.getTagList("filters", NBT.TAG_COMPOUND);
|
|
|
|
for(int i = 0; i < tagList.tagCount(); i++)
|
|
{
|
|
filters.add(OredictionificatorFilter.readFromNBT((NBTTagCompound)tagList.getCompoundTagAt(i)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public RedstoneControl getControlType()
|
|
{
|
|
return controlType;
|
|
}
|
|
|
|
@Override
|
|
public void setControlType(RedstoneControl type)
|
|
{
|
|
controlType = type;
|
|
}
|
|
|
|
@Override
|
|
public boolean canPulse()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public static class OredictionificatorFilter
|
|
{
|
|
public String filter;
|
|
public int index;
|
|
|
|
public void write(NBTTagCompound nbtTags)
|
|
{
|
|
nbtTags.setString("filter", filter);
|
|
nbtTags.setInteger("index", index);
|
|
}
|
|
|
|
protected void read(NBTTagCompound nbtTags)
|
|
{
|
|
filter = nbtTags.getString("filter");
|
|
index = nbtTags.getInteger("index");
|
|
}
|
|
|
|
public void write(ArrayList data)
|
|
{
|
|
data.add(filter);
|
|
data.add(index);
|
|
}
|
|
|
|
protected void read(ByteBuf dataStream)
|
|
{
|
|
filter = PacketHandler.readString(dataStream);
|
|
index = dataStream.readInt();
|
|
}
|
|
|
|
public static OredictionificatorFilter readFromNBT(NBTTagCompound nbtTags)
|
|
{
|
|
OredictionificatorFilter filter = new OredictionificatorFilter();
|
|
|
|
filter.read(nbtTags);
|
|
|
|
return filter;
|
|
}
|
|
|
|
public static OredictionificatorFilter readFromPacket(ByteBuf dataStream)
|
|
{
|
|
OredictionificatorFilter filter = new OredictionificatorFilter();
|
|
|
|
filter.read(dataStream);
|
|
|
|
return filter;
|
|
}
|
|
|
|
@Override
|
|
public OredictionificatorFilter clone()
|
|
{
|
|
OredictionificatorFilter newFilter = new OredictionificatorFilter();
|
|
newFilter.filter = filter;
|
|
newFilter.index = index;
|
|
|
|
return newFilter;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode()
|
|
{
|
|
int code = 1;
|
|
code = 31 * code + filter.hashCode();
|
|
return code;
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj)
|
|
{
|
|
return obj instanceof OredictionificatorFilter && ((OredictionificatorFilter)obj).filter.equals(filter);
|
|
}
|
|
}
|
|
}
|