add fluid level emitter

src/main/java/com/glodblock/github/client/gui/GuiFluidLevelEmitter.java

@@ -0,0 +1,198 @@
+package com.glodblock.github.client.gui;
+
+import appeng.api.config.*;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.client.gui.implementations.GuiUpgradeable;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiNumberBox;
+import appeng.client.render.AppEngRenderItem;
+import appeng.core.AEConfig;
+import appeng.core.AELog;
+import appeng.core.localization.GuiColors;
+import appeng.core.localization.GuiText;
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.gui.container.ContainerFluidLevelEmitter;
+import com.glodblock.github.common.parts.PartFluidLevelEmitter;
+import com.glodblock.github.network.CPacketValueConfig;
+import com.glodblock.github.util.Ae2ReflectClient;
+import com.glodblock.github.util.NameConst;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+
+public class GuiFluidLevelEmitter extends GuiUpgradeable {
+    private GuiNumberBox level;
+    private final AppEngRenderItem stackSizeRenderer = Ae2ReflectClient.getStackSizeRenderer(this);
+    private GuiButton plus1;
+    private GuiButton plus10;
+    private GuiButton plus100;
+    private GuiButton plus1000;
+    private GuiButton minus1;
+    private GuiButton minus10;
+    private GuiButton minus100;
+    private GuiButton minus1000;
+    private boolean isMul = false;
+
+    public GuiFluidLevelEmitter(final InventoryPlayer inventoryPlayer, final PartFluidLevelEmitter te) {
+        super(new ContainerFluidLevelEmitter(inventoryPlayer, te));
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+
+        this.level = new GuiNumberBox(this.fontRendererObj, 24, 43, 79, this.fontRendererObj.FONT_HEIGHT, Long.class);
+        this.level.setEnableBackgroundDrawing(false);
+        this.level.setMaxStringLength(16);
+        this.level.setTextColor(GuiColors.LevelEmitterValue.getColor());
+        this.level.setVisible(true);
+        this.level.setFocused(true);
+        ((ContainerFluidLevelEmitter) this.inventorySlots).setTextField(this.level);
+    }
+
+    @Override
+    protected void addButtons() {
+        this.redstoneMode = new GuiImgButton(
+                this.guiLeft - 18, this.guiTop + 8, Settings.REDSTONE_EMITTER, RedstoneMode.LOW_SIGNAL);
+
+        final int a = AEConfig.instance.levelByStackAmounts(0);
+        final int b = AEConfig.instance.levelByStackAmounts(1);
+        final int c = AEConfig.instance.levelByStackAmounts(2);
+        final int d = AEConfig.instance.levelByStackAmounts(3);
+
+        this.buttonList.add(this.plus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 17, 22, 20, "+" + a));
+        this.buttonList.add(this.plus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 17, 28, 20, "+" + b));
+        this.buttonList.add(this.plus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 17, 32, 20, "+" + c));
+        this.buttonList.add(this.plus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 17, 38, 20, "+" + d));
+
+        this.buttonList.add(this.minus1 = new GuiButton(0, this.guiLeft + 20, this.guiTop + 59, 22, 20, "-" + a));
+        this.buttonList.add(this.minus10 = new GuiButton(0, this.guiLeft + 48, this.guiTop + 59, 28, 20, "-" + b));
+        this.buttonList.add(this.minus100 = new GuiButton(0, this.guiLeft + 82, this.guiTop + 59, 32, 20, "-" + c));
+        this.buttonList.add(this.minus1000 = new GuiButton(0, this.guiLeft + 120, this.guiTop + 59, 38, 20, "-" + d));
+
+        this.buttonList.add(this.redstoneMode);
+    }
+
+    @Override
+    public void drawFG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
+        this.fontRendererObj.drawString(
+                NameConst.i18n(NameConst.GUI_FLUID_LEVEL_EMITTER), 8, 6, GuiColors.UpgradableTitle.getColor());
+        this.fontRendererObj.drawString(
+                GuiText.inventory.getLocal(), 8, this.ySize - 96 + 3, GuiColors.UpgradableInventory.getColor());
+        this.redstoneMode.set(this.cvb.getRedStoneMode());
+        this.level.drawTextBox();
+        if (isShiftKeyDown() && !isMul) {
+            for (Object btn : this.buttonList) {
+                if (btn instanceof GuiButton) {
+                    ((GuiButton) btn).displayString += "000";
+                }
+            }
+            isMul = true;
+        } else if (!isShiftKeyDown() && isMul) {
+            for (Object btn : this.buttonList) {
+                if (btn instanceof GuiButton) {
+                    ((GuiButton) btn).displayString = ((GuiButton) btn)
+                            .displayString.substring(0, ((GuiButton) btn).displayString.lastIndexOf("000"));
+                }
+            }
+            isMul = false;
+        }
+    }
+
+    @Override
+    public void drawBG(final int offsetX, final int offsetY, final int mouseX, final int mouseY) {
+        super.drawBG(offsetX, offsetY, mouseX, mouseY);
+    }
+
+    @Override
+    protected void handleButtonVisibility() {}
+
+    @Override
+    protected String getBackground() {
+        return "guis/lvlemitter.png";
+    }
+
+    @Override
+    protected void actionPerformed(final GuiButton btn) {
+        super.actionPerformed(btn);
+        final boolean isPlus = btn == this.plus1 || btn == this.plus10 || btn == this.plus100 || btn == this.plus1000;
+        final boolean isMinus =
+                btn == this.minus1 || btn == this.minus10 || btn == this.minus100 || btn == this.minus1000;
+
+        if (isPlus || isMinus) {
+            this.addQty(this.getQty(btn));
+        }
+    }
+
+    private void addQty(final long i) {
+        try {
+            String Out = this.level.getText();
+
+            boolean Fixed = false;
+            while (Out.startsWith("0") && Out.length() > 1) {
+                Out = Out.substring(1);
+                Fixed = true;
+            }
+
+            if (Fixed) {
+                this.level.setText(Out);
+            }
+
+            if (Out.isEmpty()) {
+                Out = "0";
+            }
+
+            long result = Long.parseLong(Out);
+            result += i;
+            if (result < 0) {
+                result = 0;
+            }
+
+            this.level.setText(Out = Long.toString(result));
+
+            FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(result, 0));
+        } catch (final NumberFormatException e) {
+            // nope..
+            this.level.setText("0");
+        }
+    }
+
+    @Override
+    protected void keyTyped(final char character, final int key) {
+        if (!this.checkHotbarKeys(key)) {
+            if ((key == 211 || key == 205 || key == 203 || key == 14 || Character.isDigit(character))
+                    && this.level.textboxKeyTyped(character, key)) {
+                try {
+                    String Out = this.level.getText();
+
+                    boolean Fixed = false;
+                    while (Out.startsWith("0") && Out.length() > 1) {
+                        Out = Out.substring(1);
+                        Fixed = true;
+                    }
+
+                    if (Fixed) {
+                        this.level.setText(Out);
+                    }
+
+                    if (Out.isEmpty()) {
+                        Out = "0";
+                    }
+                    FluidCraft.proxy.netHandler.sendToServer(new CPacketValueConfig(Long.parseLong(Out), 0));
+                } catch (final NumberFormatException e) {
+                    AELog.debug(e);
+                }
+            } else {
+                super.keyTyped(character, key);
+            }
+        }
+    }
+
+    @Override
+    protected boolean drawUpgrades() {
+        return false;
+    }
+
+    public void update(Integer key, IAEFluidStack value) {
+        ((ContainerFluidLevelEmitter) this.cvb).getBus().setFluidInSlot(key, value);
+    }
+}

src/main/java/com/glodblock/github/client/gui/container/ContainerFluidLevelEmitter.java

@@ -0,0 +1,98 @@
+package com.glodblock.github.client.gui.container;
+
+import appeng.api.config.*;
+import appeng.api.implementations.IUpgradeableHost;
+import appeng.container.guisync.GuiSync;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.util.Platform;
+import com.glodblock.github.common.parts.PartFluidLevelEmitter;
+import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly;
+import com.glodblock.github.util.Ae2Reflect;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.IInventory;
+
+public class ContainerFluidLevelEmitter extends ContainerFluidConfigurable {
+    private final PartFluidLevelEmitter lvlEmitter;
+
+    @SideOnly(Side.CLIENT)
+    private GuiTextField textField;
+
+    @GuiSync(2)
+    public long EmitterValue = -1;
+
+    public ContainerFluidLevelEmitter(final InventoryPlayer ip, final PartFluidLevelEmitter te) {
+        super(ip, te);
+        this.lvlEmitter = te;
+    }
+
+    public PartFluidLevelEmitter getBus() {
+        return this.lvlEmitter;
+    }
+
+    protected IUpgradeableHost getUpgradeable() {
+        return Ae2Reflect.getUpgradeableHost(this);
+    }
+
+    public AppEngInternalAEInventory getFakeFluidInv() {
+        return (AppEngInternalAEInventory) this.lvlEmitter.getInventoryByName("config");
+    }
+
+    @Override
+    protected void setupConfig() {
+        final IInventory inv = this.getUpgradeable().getInventoryByName("config");
+        final int y = 40;
+        final int x = 80 + 44;
+        this.addSlotToContainer(new OptionalFluidSlotFakeTypeOnly(inv, null, this, 0, x, y, 0, 0, 0));
+    }
+
+    @SideOnly(Side.CLIENT)
+    public void setTextField(final GuiTextField level) {
+        this.textField = level;
+        this.textField.setText(String.valueOf(this.EmitterValue));
+    }
+
+    public void setLevel(final long l, final EntityPlayer player) {
+        this.lvlEmitter.setReportingValue(l);
+        this.EmitterValue = l;
+    }
+
+    @Override
+    protected boolean supportCapacity() {
+        return false;
+    }
+
+    @Override
+    public int availableUpgrades() {
+        return 0;
+    }
+
+    public void setRedStoneMode(final RedstoneMode rsMode) {
+        this.rsMode = rsMode;
+    }
+
+    @Override
+    public void detectAndSendChanges() {
+        this.verifyPermissions(SecurityPermissions.BUILD, false);
+
+        if (Platform.isServer()) {
+            this.EmitterValue = this.lvlEmitter.getReportingValue();
+            this.setRedStoneMode((RedstoneMode)
+                    Ae2Reflect.getUpgradeableHost(this).getConfigManager().getSetting(Settings.REDSTONE_EMITTER));
+        }
+
+        this.standardDetectAndSendChanges();
+    }
+
+    @Override
+    public void onUpdate(final String field, final Object oldValue, final Object newValue) {
+        if (field.equals("EmitterValue")) {
+            if (this.textField != null) {
+                this.textField.setText(String.valueOf(this.EmitterValue));
+            }
+        }
+    }
+}

src/main/java/com/glodblock/github/client/textures/FCPartsTexture.java

@@ -21,6 +21,7 @@ public enum FCPartsTexture {
     BlockFluidInterfaceAlternate_Arrow("fluid_interface_arrow"),
     BlockInterfaceAlternate("fluid_interface_a"),
     BlockInterface_Face("fluid_interface"),
+    PartFluidLevelEmitter("fluid_level_emitter"),
     BlockLevelMaintainer("level_maintainer"),
     BlockLevelMaintainer_Active("level_maintainer_active");
 

src/main/java/com/glodblock/github/common/item/ItemFluidLevelEmitter.java

@@ -0,0 +1,74 @@
+package com.glodblock.github.common.item;
+
+import appeng.api.AEApi;
+import appeng.api.parts.IPart;
+import appeng.api.parts.IPartItem;
+import com.glodblock.github.FluidCraft;
+import com.glodblock.github.client.textures.FCPartsTexture;
+import com.glodblock.github.common.parts.PartFluidLevelEmitter;
+import com.glodblock.github.common.tabs.FluidCraftingTabs;
+import com.glodblock.github.util.NameConst;
+import cpw.mods.fml.common.registry.GameRegistry;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Nullable;
+
+public class ItemFluidLevelEmitter extends Item implements IPartItem {
+
+    public ItemFluidLevelEmitter() {
+        this.setMaxStackSize(64);
+        this.setUnlocalizedName(NameConst.ITEM_PART_FLUID_LEVEL_EMITTER);
+        AEApi.instance().partHelper().setItemBusRenderer(this);
+    }
+
+    @Nullable
+    @Override
+    public IPart createPartFromItemStack(ItemStack is) {
+        return new PartFluidLevelEmitter(is);
+    }
+
+    @Override
+    public boolean onItemUse(
+            ItemStack stack,
+            EntityPlayer player,
+            World world,
+            int x,
+            int y,
+            int z,
+            int side,
+            float xOffset,
+            float yOffset,
+            float zOffset) {
+        return AEApi.instance().partHelper().placeBus(player.getHeldItem(), x, y, z, side, player, world);
+    }
+
+    public ItemFluidLevelEmitter register() {
+        GameRegistry.registerItem(this, NameConst.ITEM_PART_FLUID_LEVEL_EMITTER, FluidCraft.MODID);
+        setCreativeTab(FluidCraftingTabs.INSTANCE);
+        return this;
+    }
+
+    @Override
+    public IIcon getIconIndex(ItemStack is) {
+        return FCPartsTexture.PartFluidLevelEmitter.getIcon();
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public int getSpriteNumber() {
+        return 0;
+    }
+
+    public ItemStack stack(int size) {
+        return new ItemStack(this, size);
+    }
+
+    public ItemStack stack() {
+        return new ItemStack(this, 1);
+    }
+}

src/main/java/com/glodblock/github/common/parts/PartFluidLevelEmitter.java

@@ -0,0 +1,640 @@
+package com.glodblock.github.common.parts;
+
+import appeng.api.config.*;
+import appeng.api.networking.IGridNode;
+import appeng.api.networking.crafting.*;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
+import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.storage.IBaseMonitor;
+import appeng.api.networking.storage.IStackWatcher;
+import appeng.api.networking.storage.IStackWatcherHost;
+import appeng.api.networking.ticking.IGridTickable;
+import appeng.api.networking.ticking.TickRateModulation;
+import appeng.api.networking.ticking.TickingRequest;
+import appeng.api.parts.IPartCollisionHelper;
+import appeng.api.parts.IPartRenderHelper;
+import appeng.api.storage.IMEMonitor;
+import appeng.api.storage.IMEMonitorHandlerReceiver;
+import appeng.api.storage.StorageChannel;
+import appeng.api.storage.data.IAEFluidStack;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
+import appeng.api.util.AECableType;
+import appeng.api.util.IConfigManager;
+import appeng.client.texture.CableBusTextures;
+import appeng.core.AEConfig;
+import appeng.core.AELog;
+import appeng.helpers.Reflected;
+import appeng.me.GridAccessException;
+import appeng.parts.automation.PartUpgradeable;
+import appeng.tile.inventory.AppEngInternalAEInventory;
+import appeng.tile.inventory.InvOperation;
+import appeng.util.Platform;
+import com.glodblock.github.common.item.ItemFluidPacket;
+import com.glodblock.github.inventory.InventoryHandler;
+import com.glodblock.github.inventory.gui.GuiType;
+import com.glodblock.github.util.BlockPos;
+import com.glodblock.github.util.Util;
+import cpw.mods.fml.relauncher.Side;
+import cpw.mods.fml.relauncher.SideOnly;
+import java.util.Objects;
+import java.util.Random;
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.IIcon;
+import net.minecraft.util.Vec3;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class PartFluidLevelEmitter extends PartUpgradeable
+        implements IStackWatcherHost, ICraftingWatcherHost, IMEMonitorHandlerReceiver<IAEFluidStack>, IGridTickable {
+
+    private static final int FLAG_ON = 8;
+
+    private final AppEngInternalAEInventory config = new AppEngInternalAEInventory(this, 1);
+
+    private boolean prevState = false;
+
+    private long lastReportedValue = 0;
+    private long reportingValue = 0;
+
+    private IStackWatcher myWatcher;
+    private double centerX;
+    private double centerY;
+    private double centerZ;
+
+    private int lastWorkingTick = 0;
+    private boolean delayedUpdatesQueued = false;
+
+    @Reflected
+    public PartFluidLevelEmitter(final ItemStack is) {
+        super(is);
+
+        this.getConfigManager().registerSetting(Settings.REDSTONE_EMITTER, RedstoneMode.LOW_SIGNAL);
+
+        // Workaround the emitter randomly breaking on world load
+        if (MinecraftServer.getServer() != null) {
+            delayedUpdatesQueued = true;
+            lastWorkingTick = MinecraftServer.getServer().getTickCounter();
+        }
+    }
+
+    public long getReportingValue() {
+        return this.reportingValue;
+    }
+
+    public void setReportingValue(final long v) {
+        this.reportingValue = v;
+        this.updateState();
+    }
+
+    @MENetworkEventSubscribe
+    public void powerChanged(final MENetworkPowerStatusChange c) {
+        this.updateState();
+    }
+
+    private void updateState() {
+        final boolean isOn = this.isLevelEmitterOn();
+        if (this.prevState != isOn) {
+            this.getHost().markForUpdate();
+            final TileEntity te = this.getHost().getTile();
+            this.prevState = isOn;
+            Platform.notifyBlocksOfNeighbors(te.getWorldObj(), te.xCoord, te.yCoord, te.zCoord);
+            Platform.notifyBlocksOfNeighbors(
+                    te.getWorldObj(),
+                    te.xCoord + this.getSide().offsetX,
+                    te.yCoord + this.getSide().offsetY,
+                    te.zCoord + this.getSide().offsetZ);
+        }
+    }
+
+    private boolean isLevelEmitterOn() {
+        if (Platform.isClient()) {
+            return (this.getClientFlags() & FLAG_ON) == FLAG_ON;
+        }
+
+        if (!this.getProxy().isActive()) {
+            return false;
+        }
+
+        final boolean flipState =
+                this.getConfigManager().getSetting(Settings.REDSTONE_EMITTER) == RedstoneMode.LOW_SIGNAL;
+        return flipState
+                ? this.reportingValue >= this.lastReportedValue + 1
+                : this.reportingValue < this.lastReportedValue + 1;
+    }
+
+    @MENetworkEventSubscribe
+    public void channelChanged(final MENetworkChannelsChanged c) {
+        this.updateState();
+    }
+
+    @Override
+    protected int populateFlags(final int cf) {
+        return cf | (this.prevState ? FLAG_ON : 0);
+    }
+
+    @Override
+    public IIcon getBreakingTexture() {
+        return this.getItemStack().getIconIndex();
+    }
+
+    @Override
+    public void updateWatcher(final ICraftingWatcher newWatcher) {
+        this.configureWatchers();
+    }
+
+    @Override
+    public void onRequestChange(final ICraftingGrid craftingGrid, final IAEItemStack what) {
+        this.updateState();
+    }
+
+    private IAEFluidStack getIAEFluidStack() {
+        final FluidStack fs = ItemFluidPacket.getFluidStack(this.config.getAEStackInSlot(0));
+        if (fs != null) return Util.FluidUtil.createAEFluidStack(fs);
+        return null;
+    }
+
+    // update the system...
+    private void configureWatchers() {
+        final IAEFluidStack myStack = this.getIAEFluidStack();
+
+        if (this.myWatcher != null) {
+            this.myWatcher.clear();
+        }
+
+        try {
+            this.getProxy().getStorage().getFluidInventory().removeListener(this);
+            if (this.myWatcher != null && myStack != null) {
+                this.myWatcher.add(myStack);
+            }
+            this.updateReportingValue(this.getProxy().getStorage().getFluidInventory());
+        } catch (final GridAccessException e1) {
+            // :/
+        }
+    }
+
+    private void updateReportingValue(final IMEMonitor<IAEFluidStack> monitor) {
+        final IAEFluidStack myStack = this.getIAEFluidStack();
+
+        if (myStack == null) {
+            this.lastReportedValue = 0;
+            for (final IAEFluidStack st : monitor.getStorageList()) {
+                this.lastReportedValue += st.getStackSize();
+            }
+        } else {
+            final IAEFluidStack r = monitor.getStorageList().findPrecise(myStack);
+            if (r == null) {
+                this.lastReportedValue = 0;
+            } else {
+                this.lastReportedValue = r.getStackSize();
+            }
+        }
+
+        this.updateState();
+    }
+
+    @Override
+    public void updateWatcher(final IStackWatcher newWatcher) {
+        this.myWatcher = newWatcher;
+        this.configureWatchers();
+    }
+
+    @Override
+    public void onStackChange(
+            final IItemList o,
+            final IAEStack fullStack,
+            final IAEStack diffStack,
+            final BaseActionSource src,
+            final StorageChannel chan) {
+        if (chan == StorageChannel.FLUIDS && fullStack.equals(this.getIAEFluidStack())) {
+            this.lastReportedValue = fullStack.getStackSize();
+            this.updateState();
+        }
+    }
+
+    @Override
+    public boolean isValid(final Object effectiveGrid) {
+        try {
+            return this.getProxy().getGrid() == effectiveGrid;
+        } catch (final GridAccessException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public TickingRequest getTickingRequest(IGridNode node) {
+        return new TickingRequest(
+                AEConfig.instance.levelEmitterDelay / 2,
+                AEConfig.instance.levelEmitterDelay,
+                !delayedUpdatesQueued,
+                true);
+    }
+
+    private boolean canDoWork() {
+        int currentTick = MinecraftServer.getServer().getTickCounter();
+        return (currentTick - lastWorkingTick) > AEConfig.instance.levelEmitterDelay;
+    }
+
+    @Override
+    public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) {
+        if (delayedUpdatesQueued && canDoWork()) {
+            delayedUpdatesQueued = false;
+            lastWorkingTick = MinecraftServer.getServer().getTickCounter();
+            this.onListUpdate();
+        }
+        return delayedUpdatesQueued ? TickRateModulation.IDLE : TickRateModulation.SLEEP;
+    }
+
+    @Override
+    public void postChange(
+            final IBaseMonitor<IAEFluidStack> monitor,
+            final Iterable<IAEFluidStack> change,
+            final BaseActionSource actionSource) {
+        if (canDoWork()) {
+            if (delayedUpdatesQueued) {
+                delayedUpdatesQueued = false;
+                try {
+                    this.getProxy().getTick().sleepDevice(this.getProxy().getNode());
+                } catch (GridAccessException e) {
+                    AELog.error(e, "Couldn't put level emitter to sleep after cancelling delayed updates");
+                }
+            }
+            lastWorkingTick = MinecraftServer.getServer().getTickCounter();
+            this.updateReportingValue((IMEMonitor<IAEFluidStack>) monitor);
+        } else if (!delayedUpdatesQueued) {
+            delayedUpdatesQueued = true;
+            try {
+                this.getProxy().getTick().alertDevice(this.getProxy().getNode());
+            } catch (GridAccessException e) {
+                AELog.error(e, "Couldn't wake up level emitter for delayed updates");
+            }
+        }
+    }
+
+    @Override
+    public void onListUpdate() {
+        try {
+            this.updateReportingValue(this.getProxy().getStorage().getFluidInventory());
+        } catch (final GridAccessException e) {
+            // ;P
+        }
+    }
+
+    @Override
+    public AECableType getCableConnectionType(final ForgeDirection dir) {
+        return AECableType.SMART;
+    }
+
+    @Override
+    public void getBoxes(final IPartCollisionHelper bch) {
+        bch.addBox(7, 7, 11, 9, 9, 16);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderInventory(final IPartRenderHelper rh, final RenderBlocks renderer) {
+        rh.setTexture(this.getItemStack().getIconIndex());
+        Tessellator.instance.startDrawingQuads();
+        this.renderTorchAtAngle(0, -0.5, 0);
+        Tessellator.instance.draw();
+        // rh.setBounds( 7, 7, 10, 9, 9, 15 );
+        // rh.renderInventoryBox( renderer );
+    }
+
+    private void renderTorchAtAngle(double baseX, double baseY, double baseZ) {
+        final boolean isOn = this.isLevelEmitterOn();
+        final IIcon offTexture = this.getItemStack().getIconIndex();
+        final IIcon IIcon = (isOn ? CableBusTextures.LevelEmitterTorchOn.getIcon() : offTexture);
+        //
+        this.centerX = baseX + 0.5;
+        this.centerY = baseY + 0.5;
+        this.centerZ = baseZ + 0.5;
+
+        baseY += 7.0 / 16.0;
+
+        // double par11 = 0;
+
+        /*
+         * double d5 = (double)IIcon.func_94209_e(); double d6 = (double)IIcon.func_94206_g(); double d7 =
+         * (double)IIcon.func_94212_f(); double d8 = (double)IIcon.func_94210_h(); double d9 =
+         * (double)IIcon.func_94214_a(7.0D); double d10 = (double)IIcon.func_94207_b(6.0D); double d11 =
+         * (double)IIcon.func_94214_a(9.0D); double d12 = (double)IIcon.func_94207_b(8.0D); double d13 =
+         * (double)IIcon.func_94214_a(7.0D); double d14 = (double)IIcon.func_94207_b(13.0D); double d15 =
+         * (double)IIcon.func_94214_a(9.0D); double d16 = (double)IIcon.func_94207_b(15.0D);
+         */
+
+        final float var16 = IIcon.getMinU();
+        final float var17 = IIcon.getMaxU();
+        final float var18 = IIcon.getMinV();
+        final float var19 = IIcon.getMaxV();
+        /*
+         * float var16 = (float)var14 / 256.0F; float var17 = ((float)var14 + 15.99F) / 256.0F; float var18 =
+         * (float)var15 / 256.0F; float var19 = ((float)var15 + 15.99F) / 256.0F;
+         */
+        final double var20b = offTexture.getInterpolatedU(7.0D);
+        final double var24b = offTexture.getInterpolatedU(9.0D);
+
+        final double var20 = IIcon.getInterpolatedU(7.0D);
+        final double var24 = IIcon.getInterpolatedU(9.0D);
+        final double var22 = IIcon.getInterpolatedV(6.0D + (isOn ? 0 : 1.0D));
+        final double var26 = IIcon.getInterpolatedV(8.0D + (isOn ? 0 : 1.0D));
+        final double var28 = IIcon.getInterpolatedU(7.0D);
+        final double var30 = IIcon.getInterpolatedV(13.0D);
+        final double var32 = IIcon.getInterpolatedU(9.0D);
+        final double var34 = IIcon.getInterpolatedV(15.0D);
+
+        final double var22b = IIcon.getInterpolatedV(9.0D);
+        final double var26b = IIcon.getInterpolatedV(11.0D);
+
+        baseX += 0.5D;
+        baseZ += 0.5D;
+        final double var36 = baseX - 0.5D;
+        final double var38 = baseX + 0.5D;
+        final double var40 = baseZ - 0.5D;
+        final double var42 = baseZ + 0.5D;
+
+        double toff = 0.0d;
+
+        if (!isOn) {
+            toff = 1.0d / 16.0d;
+        }
+
+        final Tessellator var12 = Tessellator.instance;
+        if (isOn) {
+            var12.setColorOpaque_F(1.0F, 1.0F, 1.0F);
+            var12.setBrightness(11 << 20 | 11 << 4);
+        }
+
+        final double TorchLen = 0.625D;
+        final double var44 = 0.0625D;
+        final double Zero = 0;
+        final double par10 = 0;
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) - var44,
+                baseY + TorchLen - toff,
+                baseZ + par10 * (1.0D - TorchLen) - var44,
+                var20,
+                var22);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) - var44,
+                baseY + TorchLen - toff,
+                baseZ + par10 * (1.0D - TorchLen) + var44,
+                var20,
+                var26);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) + var44,
+                baseY + TorchLen - toff,
+                baseZ + par10 * (1.0D - TorchLen) + var44,
+                var24,
+                var26);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) + var44,
+                baseY + TorchLen - toff,
+                baseZ + par10 * (1.0D - TorchLen) - var44,
+                var24,
+                var22);
+
+        final double var422 = 0.1915D + 1.0 / 16.0;
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) + var44,
+                baseY + var422,
+                baseZ + par10 * (1.0D - TorchLen) - var44,
+                var24b,
+                var22b);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) + var44,
+                baseY + var422,
+                baseZ + par10 * (1.0D - TorchLen) + var44,
+                var24b,
+                var26b);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) - var44,
+                baseY + var422,
+                baseZ + par10 * (1.0D - TorchLen) + var44,
+                var20b,
+                var26b);
+        this.addVertexWithUV(
+                baseX + Zero * (1.0D - TorchLen) - var44,
+                baseY + var422,
+                baseZ + par10 * (1.0D - TorchLen) - var44,
+                var20b,
+                var22b);
+
+        this.addVertexWithUV(baseX + var44 + Zero, baseY, baseZ - var44 + par10, var32, var30);
+        this.addVertexWithUV(baseX + var44 + Zero, baseY, baseZ + var44 + par10, var32, var34);
+        this.addVertexWithUV(baseX - var44 + Zero, baseY, baseZ + var44 + par10, var28, var34);
+        this.addVertexWithUV(baseX - var44 + Zero, baseY, baseZ - var44 + par10, var28, var30);
+
+        this.addVertexWithUV(baseX - var44, baseY + 1.0D, var40, var16, var18);
+        this.addVertexWithUV(baseX - var44 + Zero, baseY + 0.0D, var40 + par10, var16, var19);
+        this.addVertexWithUV(baseX - var44 + Zero, baseY + 0.0D, var42 + par10, var17, var19);
+        this.addVertexWithUV(baseX - var44, baseY + 1.0D, var42, var17, var18);
+
+        this.addVertexWithUV(baseX + var44, baseY + 1.0D, var42, var16, var18);
+        this.addVertexWithUV(baseX + Zero + var44, baseY + 0.0D, var42 + par10, var16, var19);
+        this.addVertexWithUV(baseX + Zero + var44, baseY + 0.0D, var40 + par10, var17, var19);
+        this.addVertexWithUV(baseX + var44, baseY + 1.0D, var40, var17, var18);
+
+        this.addVertexWithUV(var36, baseY + 1.0D, baseZ + var44, var16, var18);
+        this.addVertexWithUV(var36 + Zero, baseY + 0.0D, baseZ + var44 + par10, var16, var19);
+        this.addVertexWithUV(var38 + Zero, baseY + 0.0D, baseZ + var44 + par10, var17, var19);
+        this.addVertexWithUV(var38, baseY + 1.0D, baseZ + var44, var17, var18);
+
+        this.addVertexWithUV(var38, baseY + 1.0D, baseZ - var44, var16, var18);
+        this.addVertexWithUV(var38 + Zero, baseY + 0.0D, baseZ - var44 + par10, var16, var19);
+        this.addVertexWithUV(var36 + Zero, baseY + 0.0D, baseZ - var44 + par10, var17, var19);
+        this.addVertexWithUV(var36, baseY + 1.0D, baseZ - var44, var17, var18);
+    }
+
+    private void addVertexWithUV(double x, double y, double z, final double u, final double v) {
+        final Tessellator var12 = Tessellator.instance;
+
+        x -= this.centerX;
+        y -= this.centerY;
+        z -= this.centerZ;
+
+        if (this.getSide() == ForgeDirection.DOWN) {
+            y = -y;
+            z = -z;
+        }
+
+        if (this.getSide() == ForgeDirection.EAST) {
+            final double m = x;
+            x = y;
+            y = m;
+            y = -y;
+        }
+
+        if (this.getSide() == ForgeDirection.WEST) {
+            final double m = x;
+            x = -y;
+            y = m;
+        }
+
+        if (this.getSide() == ForgeDirection.SOUTH) {
+            final double m = z;
+            z = y;
+            y = m;
+            y = -y;
+        }
+
+        if (this.getSide() == ForgeDirection.NORTH) {
+            final double m = z;
+            z = -y;
+            y = m;
+        }
+
+        x += this.centerX; // + orientation.offsetX * 0.4;
+        y += this.centerY; // + orientation.offsetY * 0.4;
+        z += this.centerZ; // + orientation.offsetZ * 0.4;
+
+        var12.addVertexWithUV(x, y, z, u, v);
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void renderStatic(
+            final int x, final int y, final int z, final IPartRenderHelper rh, final RenderBlocks renderer) {
+        rh.setTexture(this.getItemStack().getIconIndex());
+        // rh.setTexture( CableBusTextures.ItemPartLevelEmitterOn.getIcon() );
+
+        // rh.setBounds( 2, 2, 14, 14, 14, 16 );
+        // rh.renderBlock( x, y, z, renderer );
+
+        // rh.setBounds( 7, 7, 10, 9, 9, 15 );
+        // rh.renderBlock( x, y, z, renderer );
+
+        renderer.renderAllFaces = true;
+
+        final Tessellator tess = Tessellator.instance;
+        tess.setBrightness(rh.getBlock()
+                .getMixedBrightnessForBlock(this.getHost().getTile().getWorldObj(), x, y, z));
+        tess.setColorOpaque_F(1.0F, 1.0F, 1.0F);
+
+        this.renderTorchAtAngle(x, y, z);
+
+        renderer.renderAllFaces = false;
+
+        rh.setBounds(7, 7, 11, 9, 9, 12);
+        this.renderLights(x, y, z, rh, renderer);
+
+        // super.renderWorldBlock( world, x, y, z, block, modelId, renderer );
+    }
+
+    @Override
+    public int isProvidingStrongPower() {
+        return this.prevState ? 15 : 0;
+    }
+
+    @Override
+    public int isProvidingWeakPower() {
+        return this.prevState ? 15 : 0;
+    }
+
+    @Override
+    public void randomDisplayTick(final World world, final int x, final int y, final int z, final Random r) {
+        if (this.isLevelEmitterOn()) {
+            final ForgeDirection d = this.getSide();
+
+            final double d0 = d.offsetX * 0.45F + (r.nextFloat() - 0.5F) * 0.2D;
+            final double d1 = d.offsetY * 0.45F + (r.nextFloat() - 0.5F) * 0.2D;
+            final double d2 = d.offsetZ * 0.45F + (r.nextFloat() - 0.5F) * 0.2D;
+
+            world.spawnParticle("reddust", 0.5 + x + d0, 0.5 + y + d1, 0.5 + z + d2, 0.0D, 0.0D, 0.0D);
+        }
+    }
+
+    @Override
+    public int cableConnectionRenderTo() {
+        return 16;
+    }
+
+    @Override
+    public boolean onPartActivate(final EntityPlayer player, final Vec3 pos) {
+        if (!player.isSneaking()) {
+            if (Platform.isClient()) {
+                return true;
+            }
+            InventoryHandler.openGui(
+                    player,
+                    this.getHost().getTile().getWorldObj(),
+                    new BlockPos(this.getHost().getTile()),
+                    Objects.requireNonNull(Util.from(getSide())),
+                    GuiType.FLUID_LEVEL_EMITTER);
+            return true;
+        }
+
+        return false;
+    }
+
+    @Override
+    public void updateSetting(final IConfigManager manager, final Enum settingName, final Enum newValue) {
+        this.configureWatchers();
+    }
+
+    @Override
+    public void onChangeInventory(
+            final IInventory inv,
+            final int slot,
+            final InvOperation mc,
+            final ItemStack removedStack,
+            final ItemStack newStack) {
+        if (inv == this.config) {
+            this.configureWatchers();
+        }
+        super.onChangeInventory(inv, slot, mc, removedStack, newStack);
+    }
+
+    @Override
+    public void upgradesChanged() {
+        this.configureWatchers();
+    }
+
+    @Override
+    public boolean canConnectRedstone() {
+        return true;
+    }
+
+    @Override
+    public void readFromNBT(final NBTTagCompound data) {
+        super.readFromNBT(data);
+        this.lastReportedValue = data.getLong("lastReportedValue");
+        this.reportingValue = data.getLong("reportingValue");
+        this.prevState = data.getBoolean("prevState");
+        this.config.readFromNBT(data, "config");
+    }
+
+    @Override
+    public void writeToNBT(final NBTTagCompound data) {
+        super.writeToNBT(data);
+        data.setLong("lastReportedValue", this.lastReportedValue);
+        data.setLong("reportingValue", this.reportingValue);
+        data.setBoolean("prevState", this.prevState);
+        this.config.writeToNBT(data, "config");
+    }
+
+    public void setFluidInSlot(int id, IAEFluidStack fluid) {
+        ItemStack tmp = ItemFluidPacket.newDisplayStack(fluid == null ? null : fluid.getFluidStack());
+        this.config.setInventorySlotContents(id, tmp);
+    }
+
+    @Override
+    public IInventory getInventoryByName(final String name) {
+        if (name.equals("config")) {
+            return this.config;
+        }
+
+        return super.getInventoryByName(name);
+    }
+}

src/main/java/com/glodblock/github/inventory/gui/GuiType.java

@@ -10,6 +10,7 @@ import com.glodblock.github.client.gui.*;
 import com.glodblock.github.client.gui.container.*;
 import com.glodblock.github.common.parts.FCBasePart;
 import com.glodblock.github.common.parts.PartFluidInterface;
+import com.glodblock.github.common.parts.PartFluidLevelEmitter;
 import com.glodblock.github.common.parts.PartSharedFluidBus;
 import com.glodblock.github.common.tile.*;
 import com.google.common.collect.ImmutableList;
@@ -18,6 +19,17 @@ import javax.annotation.Nullable;
 import net.minecraft.entity.player.EntityPlayer;
 
 public enum GuiType {
+    FLUID_LEVEL_EMITTER(new PartGuiFactory<PartFluidLevelEmitter>(PartFluidLevelEmitter.class) {
+        @Override
+        protected Object createServerGui(EntityPlayer player, PartFluidLevelEmitter inv) {
+            return new ContainerFluidLevelEmitter(player.inventory, inv);
+        }
+
+        @Override
+        protected Object createClientGui(EntityPlayer player, PartFluidLevelEmitter inv) {
+            return new GuiFluidLevelEmitter(player.inventory, inv);
+        }
+    }),
     LEVEL_MAINTAINER(new TileGuiFactory<TileLevelMaintainer>(TileLevelMaintainer.class) {
         @Override
         protected Object createServerGui(EntityPlayer player, TileLevelMaintainer inv) {

src/main/java/com/glodblock/github/loader/ChannelLoader.java

@@ -33,6 +33,8 @@ public class ChannelLoader implements Runnable {
                 new SPacketFluidUpdate.Handler(), SPacketFluidUpdate.class, id++, Side.CLIENT);
         FluidCraft.proxy.netHandler.registerMessage(
                 new CPacketPatternValueSet.Handler(), CPacketPatternValueSet.class, id++, Side.SERVER);
+        FluidCraft.proxy.netHandler.registerMessage(
+                new CPacketValueConfig.Handler(), CPacketValueConfig.class, id++, Side.SERVER);
         FluidCraft.proxy.netHandler.registerMessage(
                 new CPacketFluidUpdate.Handler(), CPacketFluidUpdate.class, id++, Side.SERVER);
         FluidCraft.proxy.netHandler.registerMessage(

src/main/java/com/glodblock/github/loader/ItemAndBlockHolder.java

@@ -25,6 +25,7 @@ public class ItemAndBlockHolder {
     public static ItemPartFluidInterface FLUID_INTERFACE = new ItemPartFluidInterface().register();
     public static ItemFluidImportBus FLUID_IMPORT_BUS = new ItemFluidImportBus().register();
     public static ItemFluidExportBus FLUID_EXPORT_BUS = new ItemFluidExportBus().register();
+    public static ItemFluidLevelEmitter FLUID_LEVEL_EMITTER = new ItemFluidLevelEmitter().register();
     public static ItemFluidPacket PACKET = new ItemFluidPacket().register();
     public static ItemBasicFluidStorageCell CELL1K = new ItemBasicFluidStorageCell(CellType.Cell1kPart, 1).register();
     public static ItemBasicFluidStorageCell CELL4K = new ItemBasicFluidStorageCell(CellType.Cell4kPart, 4).register();

src/main/java/com/glodblock/github/loader/RecipeLoader.java

@@ -1,6 +1,7 @@
 package com.glodblock.github.loader;
 
 import static com.glodblock.github.loader.ItemAndBlockHolder.*;
+import static net.minecraft.init.Blocks.redstone_torch;
 
 import com.glodblock.github.common.Config;
 import com.glodblock.github.common.item.ItemBasicFluidStorageCell;
@@ -139,6 +140,8 @@ public class RecipeLoader implements Runnable {
                 AE2_CORE_FOM,
                 'B',
                 BUCKET));
+        GameRegistry.addRecipe(new ShapedOreRecipe(
+                FLUID_LEVEL_EMITTER.stack(), "RPD", 'R', redstone_torch, 'P', AE2_PROCESS_CAL, 'D', "dyeBlue"));
         GameRegistry.addRecipe(new ShapedOreRecipe(
                 LARGE_BUFFER.stack(),
                 "BGB",

src/main/java/com/glodblock/github/network/CPacketValueConfig.java

@@ -0,0 +1,48 @@
+package com.glodblock.github.network;
+
+import com.glodblock.github.client.gui.container.ContainerFluidLevelEmitter;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.Container;
+
+public class CPacketValueConfig implements IMessage {
+    private long amount;
+    private int valueIndex;
+
+    public CPacketValueConfig() {}
+
+    public CPacketValueConfig(long amount, int valueIndex) {
+        this.amount = amount;
+        this.valueIndex = valueIndex;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        this.amount = buf.readLong();
+        this.valueIndex = buf.readInt();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeLong(amount);
+        buf.writeInt(valueIndex);
+    }
+
+    public static class Handler implements IMessageHandler<CPacketValueConfig, IMessage> {
+
+        @Override
+        public IMessage onMessage(CPacketValueConfig message, MessageContext ctx) {
+            EntityPlayer player = ctx.getServerHandler().playerEntity;
+            if (player.openContainer != null) {
+                Container container = player.openContainer;
+                if (container instanceof ContainerFluidLevelEmitter) {
+                    ((ContainerFluidLevelEmitter) container).setLevel(message.amount, player);
+                }
+            }
+            return null;
+        }
+    }
+}

src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java

@@ -111,6 +111,10 @@ public class SPacketFluidUpdate implements IMessage {
                 } else {
                     ((GuiFluidTerminal) gs).update(null);
                 }
+            } else if (gs instanceof GuiFluidLevelEmitter) {
+                for (Map.Entry<Integer, IAEFluidStack> e : message.list.entrySet()) {
+                    ((GuiFluidLevelEmitter) gs).update(e.getKey(), e.getValue());
+                }
             }
             return null;
         }

src/main/java/com/glodblock/github/util/NameConst.java

@@ -25,6 +25,7 @@ public class NameConst {
     public static final String ITEM_PART_FLUID_INTERFACE = "part_fluid_interface";
     public static final String ITEM_PART_FLUID_IMPORT = "part_fluid_import";
     public static final String ITEM_PART_FLUID_EXPORT = "part_fluid_export";
+    public static final String ITEM_PART_FLUID_LEVEL_EMITTER = "part_fluid_level_emitter";
     public static final String ITEM_FLUID_PACKET = "fluid_packet";
     public static final String ITEM_FLUID_STORAGE = "fluid_storage";
     public static final String ITEM_FLUID_PART = "fluid_part";
@@ -66,6 +67,7 @@ public class NameConst {
     public static final String RES_KEY = FluidCraft.MODID + ":";
 
     public static final String GUI_KEY = FluidCraft.MODID + ".gui.";
+    public static final String GUI_FLUID_LEVEL_EMITTER = GUI_KEY + ITEM_PART_FLUID_LEVEL_EMITTER;
     public static final String GUI_FLUID_TERMINAL = GUI_KEY + ITEM_PART_FLUID_TERMINAL;
     public static final String GUI_FLUID_PATTERN_TERMINAL = GUI_KEY + ITEM_PART_FLUID_PATTERN_TERMINAL;
     public static final String GUI_FLUID_PATTERN_TERMINAL_EX = GUI_KEY + ITEM_PART_FLUID_PATTERN_TERMINAL_EX;