private void onMonitorUpdate(final IMEMonitor<IAEFluidStack> monitor) {
// Do we have a filter?
if (this.filterAspect == null) {
// Set the current amount to 0
this.setCurrentAmount(0);
}
// Get the gas for the filter aspect
GaseousEssentia aspectGas = GaseousEssentia.getGasFromAspect(this.filterAspect);
// Is there a fluid form of the aspect?
if (aspectGas == null) {
// Set the current amount to 0
this.setCurrentAmount(0);
}
// Convert to AE fluid stack
IAEFluidStack asGasStack =
EssentiaConversionHelper.instance.createAEFluidStackInFluidUnits(aspectGas, 1);
// Get how much is in the system
IAEFluidStack fluidStack = monitor.getStorageList().findPrecise(asGasStack);
// Was there any in the system?
if (fluidStack == null) {
// Set current amount to zero
this.setCurrentAmount(0);
} else {
// Set the current amount
this.setCurrentAmount(
EssentiaConversionHelper.instance.convertFluidAmountToEssentiaAmount(
fluidStack.getStackSize()));
}
}
public void craftOrGetItem(final PacketPatternSlot packetPatternSlot) {
if (packetPatternSlot.slotItem != null && this.getCellInventory() != null) {
final IAEItemStack out = packetPatternSlot.slotItem.copy();
InventoryAdaptor inv = new AdaptorPlayerHand(this.getPlayerInv().player);
final InventoryAdaptor playerInv =
InventoryAdaptor.getAdaptor(this.getPlayerInv().player, ForgeDirection.UNKNOWN);
if (packetPatternSlot.shift) {
inv = playerInv;
}
if (inv.simulateAdd(out.getItemStack()) != null) {
return;
}
final IAEItemStack extracted =
Platform.poweredExtraction(
this.getPowerSource(), this.getCellInventory(), out, this.getActionSource());
final EntityPlayer p = this.getPlayerInv().player;
if (extracted != null) {
inv.addItems(extracted.getItemStack());
if (p instanceof EntityPlayerMP) {
this.updateHeld((EntityPlayerMP) p);
}
this.detectAndSendChanges();
return;
}
final InventoryCrafting ic = new InventoryCrafting(new ContainerNull(), 3, 3);
final InventoryCrafting real = new InventoryCrafting(new ContainerNull(), 3, 3);
for (int x = 0; x < 9; x++) {
ic.setInventorySlotContents(
x,
packetPatternSlot.pattern[x] == null
? null
: packetPatternSlot.pattern[x].getItemStack());
}
final IRecipe r = Platform.findMatchingRecipe(ic, p.worldObj);
if (r == null) {
return;
}
final IMEMonitor<IAEItemStack> storage = this.getPatternTerminal().getItemInventory();
final IItemList<IAEItemStack> all = storage.getStorageList();
final ItemStack is = r.getCraftingResult(ic);
for (int x = 0; x < ic.getSizeInventory(); x++) {
if (ic.getStackInSlot(x) != null) {
final ItemStack pulled =
Platform.extractItemsByRecipe(
this.getPowerSource(),
this.getActionSource(),
storage,
p.worldObj,
r,
is,
ic,
ic.getStackInSlot(x),
x,
all,
Actionable.MODULATE,
ItemViewCell.createFilter(this.getViewCells()));
real.setInventorySlotContents(x, pulled);
}
}
final IRecipe rr = Platform.findMatchingRecipe(real, p.worldObj);
if (rr == r && Platform.isSameItemPrecise(rr.getCraftingResult(real), is)) {
final SlotCrafting sc = new SlotCrafting(p, real, this.cOut, 0, 0, 0);
sc.onPickupFromSlot(p, is);
for (int x = 0; x < real.getSizeInventory(); x++) {
final ItemStack failed = playerInv.addItems(real.getStackInSlot(x));
if (failed != null) {
p.dropPlayerItemWithRandomChoice(failed, false);
}
}
inv.addItems(is);
if (p instanceof EntityPlayerMP) {
this.updateHeld((EntityPlayerMP) p);
}
this.detectAndSendChanges();
} else {
for (int x = 0; x < real.getSizeInventory(); x++) {
final ItemStack failed = real.getStackInSlot(x);
if (failed != null) {
this.getCellInventory()
.injectItems(
AEItemStack.create(failed),
Actionable.MODULATE,
new MachineSource(this.getPatternTerminal()));
}
}
}
}
}
@Override
public void serverPacketData(INetworkInfo manager, AppEngPacket packet, EntityPlayer player) {
EntityPlayerMP pmp = (EntityPlayerMP) player;
Container con = pmp.openContainer;
if (con instanceof IContainerCraftingPacket) {
IContainerCraftingPacket cct = (IContainerCraftingPacket) con;
IGridNode node = cct.getNetworkNode();
if (node != null) {
IGrid grid = node.getGrid();
if (grid == null) {
return;
}
IStorageGrid inv = grid.getCache(IStorageGrid.class);
IEnergyGrid energy = grid.getCache(IEnergyGrid.class);
ISecurityGrid security = grid.getCache(ISecurityGrid.class);
IInventory craftMatrix = cct.getInventoryByName("crafting");
IInventory playerInventory = cct.getInventoryByName("player");
Actionable realForFake = cct.useRealItems() ? Actionable.MODULATE : Actionable.SIMULATE;
if (inv != null && this.recipe != null && security != null) {
InventoryCrafting testInv = new InventoryCrafting(new ContainerNull(), 3, 3);
for (int x = 0; x < 9; x++) {
if (this.recipe[x] != null && this.recipe[x].length > 0) {
testInv.setInventorySlotContents(x, this.recipe[x][0]);
}
}
IRecipe r = Platform.findMatchingRecipe(testInv, pmp.worldObj);
if (r != null && security.hasPermission(player, SecurityPermissions.EXTRACT)) {
ItemStack is = r.getCraftingResult(testInv);
if (is != null) {
IMEMonitor<IAEItemStack> storage = inv.getItemInventory();
IItemList all = storage.getStorageList();
IPartitionList<IAEItemStack> filter = ItemViewCell.createFilter(cct.getViewCells());
for (int x = 0; x < craftMatrix.getSizeInventory(); x++) {
ItemStack patternItem = testInv.getStackInSlot(x);
ItemStack currentItem = craftMatrix.getStackInSlot(x);
if (currentItem != null) {
testInv.setInventorySlotContents(x, currentItem);
ItemStack newItemStack =
r.matches(testInv, pmp.worldObj) ? r.getCraftingResult(testInv) : null;
testInv.setInventorySlotContents(x, patternItem);
if (newItemStack == null || !Platform.isSameItemPrecise(newItemStack, is)) {
IAEItemStack in = AEItemStack.create(currentItem);
if (in != null) {
IAEItemStack out =
realForFake == Actionable.SIMULATE
? null
: Platform.poweredInsert(energy, storage, in, cct.getSource());
if (out != null) {
craftMatrix.setInventorySlotContents(x, out.getItemStack());
} else {
craftMatrix.setInventorySlotContents(x, null);
}
currentItem = craftMatrix.getStackInSlot(x);
}
}
}
// True if we need to fetch an item for the recipe
if (patternItem != null && currentItem == null) {
// Grab from network by recipe
ItemStack whichItem =
Platform.extractItemsByRecipe(
energy,
cct.getSource(),
storage,
player.worldObj,
r,
is,
testInv,
patternItem,
x,
all,
realForFake,
filter);
// If that doesn't get it, grab exact items from network (?)
// TODO see if this code is necessary
if (whichItem == null) {
for (int y = 0; y < this.recipe[x].length; y++) {
IAEItemStack request = AEItemStack.create(this.recipe[x][y]);
if (request != null) {
if (filter == null || filter.isListed(request)) {
request.setStackSize(1);
IAEItemStack out =
Platform.poweredExtraction(energy, storage, request, cct.getSource());
if (out != null) {
whichItem = out.getItemStack();
break;
}
}
}
}
}
// If that doesn't work, grab from the player's inventory
if (whichItem == null && playerInventory != null) {
whichItem = extractItemFromPlayerInventory(player, realForFake, patternItem);
}
craftMatrix.setInventorySlotContents(x, whichItem);
}
}
con.onCraftMatrixChanged(craftMatrix);
}
}
}
}
}
}