diff --git a/src/main/java/com/glodblock/github/client/gui/GuiDualInterface.java b/src/main/java/com/glodblock/github/client/gui/GuiDualInterface.java new file mode 100644 index 00000000..a3b46e95 --- /dev/null +++ b/src/main/java/com/glodblock/github/client/gui/GuiDualInterface.java @@ -0,0 +1,114 @@ +package com.glodblock.github.client.gui; + +import appeng.api.config.Settings; +import appeng.api.config.YesNo; +import appeng.client.gui.implementations.GuiUpgradeable; +import appeng.client.gui.widgets.GuiImgButton; +import appeng.client.gui.widgets.GuiTabButton; +import appeng.client.gui.widgets.GuiToggleButton; +import appeng.container.implementations.ContainerInterface; +import appeng.core.localization.GuiText; +import appeng.core.sync.network.NetworkHandler; +import appeng.core.sync.packets.PacketConfigButton; +import appeng.helpers.IInterfaceHost; +import com.glodblock.github.FluidCraft; +import com.glodblock.github.inventory.gui.GuiType; +import com.glodblock.github.loader.ItemAndBlockHolder; +import com.glodblock.github.network.CPacketSwitchGuis; +import com.glodblock.github.util.ModAndClassUtil; +import com.glodblock.github.util.NameConst; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.StatCollector; +import org.lwjgl.input.Mouse; + +public class GuiDualInterface extends GuiUpgradeable { + + private GuiTabButton priority; + private GuiTabButton switcher; + private GuiImgButton BlockMode; + private GuiToggleButton interfaceMode; + + public GuiDualInterface(InventoryPlayer inventoryPlayer, IInterfaceHost te) { + super(new ContainerInterface(inventoryPlayer, te)); + this.ySize = 211; + } + + @Override + @SuppressWarnings("unchecked") + protected void addButtons() + { + this.priority = new GuiTabButton( this.guiLeft + 154, this.guiTop, 2 + 4 * 16, GuiText.Priority.getLocal(), itemRender ); + this.buttonList.add( this.priority ); + + this.switcher = new GuiTabButton( this.guiLeft + 132, this.guiTop, ItemAndBlockHolder.INTERFACE.stack(), StatCollector.translateToLocal("ae2fc.tooltip.switch_fluid_interface"), itemRender ); + this.buttonList.add( this.switcher ); + + this.BlockMode = new GuiImgButton( this.guiLeft - 18, this.guiTop + 8, Settings.BLOCK, YesNo.NO ); + this.buttonList.add( this.BlockMode ); + + this.interfaceMode = new GuiToggleButton( this.guiLeft - 18, this.guiTop + 26, 84, 85, GuiText.InterfaceTerminal.getLocal(), GuiText.InterfaceTerminalHint.getLocal() ); + this.buttonList.add( this.interfaceMode ); + } + + @Override + public void drawFG( final int offsetX, final int offsetY, final int mouseX, final int mouseY ) + { + if( this.BlockMode != null ) + { + this.BlockMode.set( ( (ContainerInterface) this.cvb ).getBlockingMode() ); + } + + if( this.interfaceMode != null ) + { + this.interfaceMode.setState( ( (ContainerInterface) this.cvb ).getInterfaceTerminalMode() == YesNo.YES ); + } + + this.fontRendererObj.drawString( StatCollector.translateToLocal(NameConst.GUI_FLUID_INTERFACE), 8, 6, 4210752 ); + } + + @Override + protected String getBackground() + { + if (!ModAndClassUtil.isBigInterface) + return "guis/interface.png"; + switch (((ContainerInterface) this.cvb).getPatternCapacityCardsInstalled()) + { + case 1: + return "guis/interface2.png"; + case 2: + return "guis/interface3.png"; + case 3: + return "guis/interface4.png"; + } + return "guis/interface.png"; + } + + @Override + protected void actionPerformed( final GuiButton btn ) + { + super.actionPerformed( btn ); + + final boolean backwards = Mouse.isButtonDown( 1 ); + + if( btn == this.priority ) + { + FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.DUAL_INTERFACE_PRIORITY)); + } + + if( btn == this.switcher ) + { + FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.DUAL_INTERFACE_FLUID)); + } + + if( btn == this.interfaceMode ) + { + NetworkHandler.instance.sendToServer( new PacketConfigButton( Settings.INTERFACE_TERMINAL, backwards ) ); + } + + if( btn == this.BlockMode ) + { + NetworkHandler.instance.sendToServer( new PacketConfigButton( this.BlockMode.getSetting(), backwards ) ); + } + } +} diff --git a/src/main/java/com/glodblock/github/client/gui/GuiFCPriority.java b/src/main/java/com/glodblock/github/client/gui/GuiFCPriority.java new file mode 100644 index 00000000..8e6e87d0 --- /dev/null +++ b/src/main/java/com/glodblock/github/client/gui/GuiFCPriority.java @@ -0,0 +1,212 @@ +package com.glodblock.github.client.gui; + +import appeng.client.gui.AEBaseGui; +import appeng.client.gui.widgets.GuiNumberBox; +import appeng.client.gui.widgets.GuiTabButton; +import appeng.container.AEBaseContainer; +import appeng.container.implementations.ContainerPriority; +import appeng.core.AEConfig; +import appeng.core.AELog; +import appeng.core.localization.GuiText; +import appeng.core.sync.network.NetworkHandler; +import appeng.core.sync.packets.PacketValueConfig; +import appeng.helpers.IPriorityHost; +import com.glodblock.github.FluidCraft; +import com.glodblock.github.common.tile.TileFluidInterface; +import com.glodblock.github.inventory.gui.GuiType; +import com.glodblock.github.loader.ItemAndBlockHolder; +import com.glodblock.github.network.CPacketSwitchGuis; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; + +import java.io.IOException; + +public class GuiFCPriority extends AEBaseGui +{ + + private GuiNumberBox priority; + private GuiTabButton originalGuiBtn; + + 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 GuiType OriginalGui; + + public GuiFCPriority( final InventoryPlayer inventoryPlayer, final IPriorityHost te ) + { + super( new ContainerPriority( inventoryPlayer, te ) ); + } + + @Override + @SuppressWarnings("unchecked") + public void initGui() + { + super.initGui(); + + final int a = AEConfig.instance.priorityByStacksAmounts( 0 ); + final int b = AEConfig.instance.priorityByStacksAmounts( 1 ); + final int c = AEConfig.instance.priorityByStacksAmounts( 2 ); + final int d = AEConfig.instance.priorityByStacksAmounts( 3 ); + + this.buttonList.add( this.plus1 = new GuiButton( 0, this.guiLeft + 20, this.guiTop + 32, 22, 20, "+" + a ) ); + this.buttonList.add( this.plus10 = new GuiButton( 0, this.guiLeft + 48, this.guiTop + 32, 28, 20, "+" + b ) ); + this.buttonList.add( this.plus100 = new GuiButton( 0, this.guiLeft + 82, this.guiTop + 32, 32, 20, "+" + c ) ); + this.buttonList.add( this.plus1000 = new GuiButton( 0, this.guiLeft + 120, this.guiTop + 32, 38, 20, "+" + d ) ); + + this.buttonList.add( this.minus1 = new GuiButton( 0, this.guiLeft + 20, this.guiTop + 69, 22, 20, "-" + a ) ); + this.buttonList.add( this.minus10 = new GuiButton( 0, this.guiLeft + 48, this.guiTop + 69, 28, 20, "-" + b ) ); + this.buttonList.add( this.minus100 = new GuiButton( 0, this.guiLeft + 82, this.guiTop + 69, 32, 20, "-" + c ) ); + this.buttonList.add( this.minus1000 = new GuiButton( 0, this.guiLeft + 120, this.guiTop + 69, 38, 20, "-" + d ) ); + + ItemStack myIcon = null; + final Object target = ( (AEBaseContainer) this.inventorySlots ).getTarget(); + + if( target instanceof TileFluidInterface) + { + myIcon = ItemAndBlockHolder.INTERFACE.stack(); + this.OriginalGui = GuiType.DUAL_INTERFACE; + } + + if( this.OriginalGui != null && myIcon != null ) + { + this.buttonList.add( this.originalGuiBtn = new GuiTabButton( this.guiLeft + 154, this.guiTop, myIcon, myIcon.getDisplayName(), itemRender ) ); + } + + this.priority = new GuiNumberBox( this.fontRendererObj, this.guiLeft + 62, this.guiTop + 57, 59, this.fontRendererObj.FONT_HEIGHT, Long.class ); + this.priority.setEnableBackgroundDrawing( false ); + this.priority.setMaxStringLength( 16 ); + this.priority.setTextColor( 0xFFFFFF ); + this.priority.setVisible( true ); + this.priority.setFocused( true ); + ( (ContainerPriority) this.inventorySlots ).setTextField( this.priority ); + } + + @Override + public void drawFG( final int offsetX, final int offsetY, final int mouseX, final int mouseY ) + { + this.fontRendererObj.drawString( GuiText.Priority.getLocal(), 8, 6, 4210752 ); + } + + @Override + public void drawBG( final int offsetX, final int offsetY, final int mouseX, final int mouseY ) + { + this.bindTexture( getBackground() ); + this.drawTexturedModalRect( offsetX, offsetY, 0, 0, this.xSize, this.ySize ); + + this.priority.drawTextBox(); + } + + @Override + protected void actionPerformed( final GuiButton btn ) + { + super.actionPerformed( btn ); + + if( btn == this.originalGuiBtn ) + { + FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(this.OriginalGui)); + } + + 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 int i ) + { + try + { + String out = this.priority.getText(); + + boolean fixed = false; + while( out.startsWith( "0" ) && out.length() > 1 ) + { + out = out.substring( 1 ); + fixed = true; + } + + if( fixed ) + { + this.priority.setText( out ); + } + + if( out.isEmpty() ) + { + out = "0"; + } + + long result = Long.parseLong( out ); + result += i; + + this.priority.setText( out = Long.toString( result ) ); + + NetworkHandler.instance.sendToServer( new PacketValueConfig( "PriorityHost.Priority", out ) ); + } + catch( final NumberFormatException e ) + { + // nope.. + this.priority.setText( "0" ); + } + catch( final IOException e ) + { + AELog.debug( e ); + } + } + + @Override + protected void keyTyped( final char character, final int key ) + { + if( !this.checkHotbarKeys( key ) ) + { + if( ( key == 211 || key == 205 || key == 203 || key == 14 || character == '-' || Character.isDigit( character ) ) && this.priority.textboxKeyTyped( character, key ) ) + { + try + { + String out = this.priority.getText(); + + boolean fixed = false; + while( out.startsWith( "0" ) && out.length() > 1 ) + { + out = out.substring( 1 ); + fixed = true; + } + + if( fixed ) + { + this.priority.setText( out ); + } + + if( out.isEmpty() ) + { + out = "0"; + } + + NetworkHandler.instance.sendToServer( new PacketValueConfig( "PriorityHost.Priority", out ) ); + } + catch( final IOException e ) + { + AELog.debug( e ); + } + } + else + { + super.keyTyped( character, key ); + } + } + } + + protected String getBackground() + { + return "guis/priority.png"; + } +} diff --git a/src/main/java/com/glodblock/github/client/gui/GuiFluidInterface.java b/src/main/java/com/glodblock/github/client/gui/GuiFluidInterface.java new file mode 100644 index 00000000..2c122423 --- /dev/null +++ b/src/main/java/com/glodblock/github/client/gui/GuiFluidInterface.java @@ -0,0 +1,113 @@ +package com.glodblock.github.client.gui; + +import appeng.api.storage.data.IAEFluidStack; +import appeng.client.gui.AEBaseGui; +import appeng.client.gui.widgets.GuiTabButton; +import appeng.core.localization.GuiText; +import com.glodblock.github.FluidCraft; +import com.glodblock.github.client.gui.container.ContainerFluidInterface; +import com.glodblock.github.common.tile.TileFluidInterface; +import com.glodblock.github.inventory.IAEFluidTank; +import com.glodblock.github.inventory.gui.GuiType; +import com.glodblock.github.loader.ItemAndBlockHolder; +import com.glodblock.github.network.CPacketSwitchGuis; +import com.glodblock.github.util.NameConst; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import net.minecraftforge.common.util.ForgeDirection; +import org.lwjgl.opengl.GL11; + +import javax.annotation.Nullable; + +public class GuiFluidInterface extends AEBaseGui { + + private static final ResourceLocation TEX_BG = FluidCraft.resource("textures/gui/interface_fluid.png"); + private static final int TANK_X = 35, TANK_X_OFF = 18, TANK_Y = 53; + private static final int TANK_WIDTH = 16, TANK_HEIGHT = 68; + + private final ContainerFluidInterface cont; + + private GuiTabButton switcher; + + public GuiFluidInterface(InventoryPlayer ipl, TileFluidInterface tile) { + super(new ContainerFluidInterface(ipl, tile)); + this.cont = (ContainerFluidInterface) inventorySlots; + this.ySize = 231; + } + + @Override + @SuppressWarnings("unchecked") + public void initGui() + { + super.initGui(); + this.switcher = new GuiTabButton( this.guiLeft + 154, this.guiTop, ItemAndBlockHolder.INTERFACE.stack(), StatCollector.translateToLocal("ae2fc.tooltip.switch_fluid_interface"), itemRender ); + this.buttonList.add( this.switcher ); + } + + @Override + public void drawFG(int offsetX, int offsetY, int mouseX, int mouseY) { + fontRendererObj.drawString(getGuiDisplayName(I18n.format(NameConst.GUI_FLUID_INTERFACE)), 8, 6, 0x404040); + fontRendererObj.drawString(GuiText.inventory.getLocal(), 8, ySize - 94, 0x404040); + GL11.glColor4f(1F, 1F, 1F, 1F); + + IAEFluidTank fluidInv = ((TileFluidInterface) cont.getTile()).getInternalFluid(); + mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture); + for (int i = 0; i < 6; i++) { + renderFluidIntoGui(TANK_X + i * TANK_X_OFF, TANK_Y, TANK_WIDTH, TANK_HEIGHT, + fluidInv.getFluidInSlot(i), fluidInv.getTankInfo(ForgeDirection.UNKNOWN)[i].capacity); + } + GL11.glColor4f(1F, 1F, 1F, 1F); + } + + @Override + public void drawBG(int offsetX, int offsetY, int mouseX, int mouseY) { + mc.getTextureManager().bindTexture(TEX_BG); + drawTexturedModalRect(offsetX, offsetY, 0, 0, 176, ySize); + } + + public void renderFluidIntoGui(int x, int y, int width, int height, + @Nullable IAEFluidStack aeFluidStack, int capacity) { + if (aeFluidStack != null) { + GL11.glDisable(2896); + GL11.glColor3f(1.0F, 1.0F, 1.0F); + int hi = (int) (height * ((double) aeFluidStack.getStackSize() / capacity)); + if (aeFluidStack.getStackSize() > 0 && hi > 0) { + Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.locationBlocksTexture); + IIcon fluidIcon = aeFluidStack.getFluid().getStillIcon(); + GL11.glColor3f((float)(aeFluidStack.getFluid().getColor() >> 16 & 255) / 255.0F, (float)(aeFluidStack.getFluid().getColor() >> 8 & 255) / 255.0F, (float)(aeFluidStack.getFluid().getColor() & 255) / 255.0F); + for (int th = 0; th <= hi; th += 16) { + if (hi - th <= 0) break; + this.drawTexturedModelRectFromIcon(x, y + height - Math.min(16, hi - th) - th, fluidIcon, width, Math.min(16, hi - th)); + } + GL11.glColor3f(1.0F, 1.0F, 1.0F); + } + } + } + + @Override + protected void actionPerformed( final GuiButton btn ) + { + super.actionPerformed(btn); + if (btn == this.switcher) { + FluidCraft.proxy.netHandler.sendToServer(new CPacketSwitchGuis(GuiType.DUAL_INTERFACE)); + } + } + + public void update(int id, IAEFluidStack stack) { + if (id >= 100) { + id -= 100; + ((TileFluidInterface) cont.getTile()).setConfig(id, stack); + } + else { + ((TileFluidInterface) cont.getTile()).setFluidInv(id, stack); + } + } + +} + diff --git a/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidConfigurable.java b/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidConfigurable.java index b9739e6e..4d385c72 100644 --- a/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidConfigurable.java +++ b/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidConfigurable.java @@ -128,11 +128,4 @@ public abstract class ContainerFluidConfigurable extends ContainerUpgradeable { super.standardDetectAndSendChanges(); } - public void setFluid(int id, IAEFluidStack fluidStack) { - final AppEngInternalAEInventory inv = this.getFakeFluidInv(); - if (inv != null && this.isValidForConfig(id, AEFluidStack.create(fluidStack))) { - ItemStack tmp = ItemFluidPacket.newDisplayStack(fluidStack.getFluidStack()); - inv.setInventorySlotContents(id, tmp); - } - } } diff --git a/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidInterface.java b/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidInterface.java new file mode 100644 index 00000000..b62421cd --- /dev/null +++ b/src/main/java/com/glodblock/github/client/gui/container/ContainerFluidInterface.java @@ -0,0 +1,64 @@ +package com.glodblock.github.client.gui.container; + +import appeng.api.storage.data.IAEFluidStack; +import appeng.container.AEBaseContainer; +import appeng.container.slot.IOptionalSlotHost; +import appeng.util.item.AEFluidStack; +import com.glodblock.github.FluidCraft; +import com.glodblock.github.common.item.ItemFluidPacket; +import com.glodblock.github.common.tile.TileFluidInterface; +import com.glodblock.github.inventory.slot.OptionalFluidSlotFakeTypeOnly; +import com.glodblock.github.network.SPacketFluidUpdate; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.IInventory; + +import java.util.HashMap; +import java.util.Map; + +public class ContainerFluidInterface extends AEBaseContainer implements IOptionalSlotHost { + + private final Object tile; + + public ContainerFluidInterface(InventoryPlayer ipl, TileFluidInterface tile) { + super(ipl, tile); + this.tile = tile; + IInventory inv = tile.getConfig(); + final int y = 35; + final int x = 35; + for (int i = 0; i < 6; i++) { + addSlotToContainer(new OptionalFluidSlotFakeTypeOnly(inv, this, i, x, y, i, 0, 0)); + } + bindPlayerInventory(ipl, 0, 149); + } + + public Object getTile() { + return tile; + } + + @Override + public boolean isSlotEnabled(int idx) { + return idx >= 0 && idx < 6; + } + + @Override + public void detectAndSendChanges() { + super.detectAndSendChanges(); + Map tmp = new HashMap<>(); + for (int i = 0; i < ((TileFluidInterface) tile).getInternalFluid().getSlots(); i ++) { + tmp.put(i, ((TileFluidInterface) tile).getInternalFluid().getFluidInSlot(i)); + } + for (int i = 0; i < ((TileFluidInterface) tile).getConfig().getSizeInventory(); i ++) { + tmp.put(i + 100, AEFluidStack.create(ItemFluidPacket.getFluidStack(((TileFluidInterface) tile).getConfig().getStackInSlot( i )))); + } + for( final Object g : this.crafters ) + { + if( g instanceof EntityPlayer) + { + FluidCraft.proxy.netHandler.sendTo(new SPacketFluidUpdate(tmp), (EntityPlayerMP) g); + } + } + } + +} diff --git a/src/main/java/com/glodblock/github/common/block/BlockFluidInterface.java b/src/main/java/com/glodblock/github/common/block/BlockFluidInterface.java index 68aac600..608caa7c 100644 --- a/src/main/java/com/glodblock/github/common/block/BlockFluidInterface.java +++ b/src/main/java/com/glodblock/github/common/block/BlockFluidInterface.java @@ -8,6 +8,9 @@ import appeng.tile.misc.TileInterface; import appeng.util.Platform; import com.glodblock.github.client.render.RenderBlockFluidInterface; import com.glodblock.github.common.tile.TileFluidInterface; +import com.glodblock.github.inventory.InventoryHandler; +import com.glodblock.github.inventory.gui.GuiType; +import com.glodblock.github.util.BlockPos; import com.glodblock.github.util.NameConst; import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.relauncher.Side; @@ -15,6 +18,7 @@ import cpw.mods.fml.relauncher.SideOnly; import net.minecraft.block.material.Material; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; @@ -38,19 +42,18 @@ public class BlockFluidInterface extends FCBaseBlock { } @Override - public boolean onActivated(final World w, final int x, final int y, final int z, final EntityPlayer p, final int side, final float hitX, final float hitY, final float hitZ ) + public boolean onActivated(final World world, final int x, final int y, final int z, final EntityPlayer player, final int facing, final float hitX, final float hitY, final float hitZ ) { - if( p.isSneaking() ) + if( player.isSneaking() ) { return false; } - - final TileInterface tg = this.getTileEntity( w, x, y, z ); + final TileInterface tg = this.getTileEntity( world, x, y, z ); if( tg != null ) { if( Platform.isServer() ) { - Platform.openGUI( p, tg, ForgeDirection.getOrientation( side ), GuiBridge.GUI_INTERFACE ); + InventoryHandler.openGui(player, world, new BlockPos(x, y, z), EnumFacing.getFront(facing), GuiType.DUAL_INTERFACE); } return true; } diff --git a/src/main/java/com/glodblock/github/common/tile/TileFluidInterface.java b/src/main/java/com/glodblock/github/common/tile/TileFluidInterface.java index 7d22731b..9516234c 100644 --- a/src/main/java/com/glodblock/github/common/tile/TileFluidInterface.java +++ b/src/main/java/com/glodblock/github/common/tile/TileFluidInterface.java @@ -8,13 +8,23 @@ import appeng.api.networking.security.MachineSource; import appeng.api.networking.storage.IStorageGrid; import appeng.api.storage.IMEMonitor; import appeng.api.storage.data.IAEFluidStack; -import appeng.core.features.IStackSrc; import appeng.me.GridAccessException; +import appeng.tile.TileEvent; +import appeng.tile.events.TileEventType; +import appeng.tile.inventory.AppEngInternalAEInventory; import appeng.tile.misc.TileInterface; import appeng.util.Platform; import appeng.util.item.AEFluidStack; +import com.glodblock.github.common.item.ItemFluidPacket; +import com.glodblock.github.inventory.AEFluidInventory; +import com.glodblock.github.inventory.IAEFluidInventory; +import com.glodblock.github.inventory.IAEFluidTank; import com.glodblock.github.loader.ItemAndBlockHolder; +import com.glodblock.github.util.Util; +import cpw.mods.fml.common.network.ByteBufUtils; +import io.netty.buffer.ByteBuf; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraftforge.common.util.ForgeDirection; import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidStack; @@ -22,11 +32,17 @@ import net.minecraftforge.fluids.FluidTankInfo; import net.minecraftforge.fluids.IFluidHandler; import javax.annotation.Nullable; +import java.io.IOException; -public class TileFluidInterface extends TileInterface implements IFluidHandler +public class TileFluidInterface extends TileInterface implements IFluidHandler, IAEFluidInventory { private final BaseActionSource ownActionSource = new MachineSource(this); + private final AEFluidInventory invFluids = new AEFluidInventory(this, 6, 16000); + private final AppEngInternalAEInventory config = new AppEngInternalAEInventory( this, 6 ); + + private final boolean[] tickState = new boolean[]{true, true, true, true, true, true}; + private final int[] tickCount = new int[]{0, 0, 0, 0, 0, 0}; private IMEMonitor getFluidGrid() { try { @@ -44,6 +60,76 @@ public class TileFluidInterface extends TileInterface implements IFluidHandler } } + public AEFluidInventory getInternalFluid() { + return invFluids; + } + + public AppEngInternalAEInventory getConfig() { + return config; + } + + @TileEvent( TileEventType.NETWORK_WRITE ) + protected void writeToStream(ByteBuf data) throws IOException { + for (int i = 0; i < config.getSizeInventory(); i++) { + ByteBufUtils.writeItemStack(data, config.getStackInSlot(i)); + } + int fluidMask = 0; + for (int i = 0; i < invFluids.getSlots(); i++) { + if (invFluids.getFluidInSlot(i) != null) { + fluidMask |= 1 << i; + } + } + data.writeByte(fluidMask); + for (int i = 0; i < invFluids.getSlots(); i++) { + IAEFluidStack fluid = invFluids.getFluidInSlot(i); + if (fluid != null) { + fluid.writeToPacket(data); + } + } + } + + @TileEvent( TileEventType.NETWORK_READ ) + protected boolean readFromStream(ByteBuf data) throws IOException { + boolean changed = false; + for (int i = 0; i < config.getSizeInventory(); i++) { + ItemStack stack = ByteBufUtils.readItemStack(data); + if (!ItemStack.areItemStacksEqual(stack, config.getStackInSlot(i))) { + config.setInventorySlotContents(i, stack); + changed = true; + } + } + int fluidMask = data.readByte(); + for (int i = 0; i < invFluids.getSlots(); i++) { + if ((fluidMask & (1 << i)) != 0) { + IAEFluidStack fluid = AEFluidStack.loadFluidStackFromPacket(data); + if (fluid != null) { // this shouldn't happen, but better safe than sorry + IAEFluidStack origFluid = invFluids.getFluidInSlot(i); + if (!fluid.equals(origFluid) || fluid.getStackSize() != origFluid.getStackSize()) { + invFluids.setFluidInSlot(i, fluid); + changed = true; + } + } + } else if (invFluids.getFluidInSlot(i) != null) { + invFluids.setFluidInSlot(i, null); + changed = true; + } + } + return changed; + } + + @TileEvent( TileEventType.WORLD_NBT_READ ) + public void readFromNBTEvent(NBTTagCompound data) { + config.readFromNBT(data, "ConfigInv"); + invFluids.readFromNBT(data, "FluidInv"); + } + + @TileEvent( TileEventType.WORLD_NBT_WRITE ) + public NBTTagCompound writeToNBTEvent(NBTTagCompound data) { + config.writeToNBT(data, "ConfigInv"); + invFluids.writeToNBT(data, "FluidInv"); + return data; + } + @Nullable protected ItemStack getItemFromTile( final Object obj ) { @@ -99,4 +185,88 @@ public class TileFluidInterface extends TileInterface implements IFluidHandler public FluidTankInfo[] getTankInfo(ForgeDirection from) { return new FluidTankInfo[]{new FluidTankInfo(null, 0)}; } + + @Override + public void onFluidInventoryChanged(IAEFluidTank inv, int slot) { + saveChanges(); + markForUpdate(); + } + + public void setConfig(int id, IAEFluidStack fluid) { + if (id >= 0 && id < 6) { + config.setInventorySlotContents(id, ItemFluidPacket.newDisplayStack(fluid == null ? null : fluid.getFluidStack())); + } + } + + public void setFluidInv(int id, IAEFluidStack fluid) { + if (id >= 0 && id < 6) { + invFluids.setFluidInSlot(id, fluid); + } + } + + @TileEvent( TileEventType.TICK ) + public void updateTick() { + //Very Hacky thing. + for (int i = 0; i < 6; i ++) { + + FluidStack configFluid = ItemFluidPacket.getFluidStack(config.getStackInSlot(i)); + FluidStack storedFluid = invFluids.getFluidInSlot(i) == null ? null : invFluids.getFluidInSlot(i).getFluidStack(); + + if (!Util.areFluidsEqual(configFluid, storedFluid)) { + if (storedFluid != null) { + int ori = storedFluid.amount; + int filled = fill(ForgeDirection.UNKNOWN, storedFluid, false); + if (ori == filled) { + fill(ForgeDirection.UNKNOWN, storedFluid, true); + invFluids.setFluidInSlot(i, null); + } + else { + tickState[i] = false; + } + } + } + + if (configFluid != null) { + if (tickState[i]) { + if (getFluidGrid() != null) { + FluidStack configCopy = configFluid.copy(); + configCopy.amount = Math.min(8000, getLeftSpace(storedFluid, configCopy)); + IAEFluidStack fluidDrain = getFluidGrid().extractItems(AEFluidStack.create(configCopy), Actionable.MODULATE, ownActionSource); + if (fluidDrain != null && fluidDrain.getStackSize() != 0) { + invFluids.fill(i, fluidDrain.getFluidStack(), true); + } else { + tickState[i] = false; + } + } + } + else if (tickCount[i] % 40 == 0) { + if (getFluidGrid() != null) { + FluidStack configCopy = configFluid.copy(); + configCopy.amount = Math.min(8000, getLeftSpace(storedFluid, configCopy)); + IAEFluidStack fluidDrain = getFluidGrid().extractItems(AEFluidStack.create(configCopy), Actionable.MODULATE, ownActionSource); + if (fluidDrain != null && fluidDrain.getStackSize() != 0) { + invFluids.fill(i, fluidDrain.getFluidStack(), true); + tickState[i] = true; + } + } + } + } + + tickCount[i] ++; + if (tickCount[i] > 500) { + tickCount[i] = 1; + } + } + } + + private int getLeftSpace(FluidStack stored, FluidStack req) { + if (stored == null) { + return 16000; + } + if (!Util.areFluidsEqual(stored, req)) { + return 0; + } + return 16000 - stored.amount; + } + } diff --git a/src/main/java/com/glodblock/github/inventory/gui/GuiType.java b/src/main/java/com/glodblock/github/inventory/gui/GuiType.java index 19c0e124..1b5eec79 100644 --- a/src/main/java/com/glodblock/github/inventory/gui/GuiType.java +++ b/src/main/java/com/glodblock/github/inventory/gui/GuiType.java @@ -3,10 +3,14 @@ package com.glodblock.github.inventory.gui; import appeng.api.storage.ITerminalHost; import appeng.container.implementations.ContainerCraftAmount; import appeng.container.implementations.ContainerCraftingStatus; +import appeng.container.implementations.ContainerInterface; +import appeng.container.implementations.ContainerPriority; +import appeng.helpers.IPriorityHost; 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.PartSharedFluidBus; +import com.glodblock.github.common.tile.TileFluidInterface; import com.glodblock.github.common.tile.TileFluidPacketDecoder; import com.glodblock.github.common.tile.TileFluidPatternEncoder; import com.glodblock.github.common.tile.TileIngredientBuffer; @@ -18,6 +22,42 @@ import java.util.List; public enum GuiType { + DUAL_INTERFACE(new TileGuiFactory(TileFluidInterface.class) { + @Override + protected Object createServerGui(EntityPlayer player, TileFluidInterface inv) { + return new ContainerInterface(player.inventory, inv); + } + + @Override + protected Object createClientGui(EntityPlayer player, TileFluidInterface inv) { + return new GuiDualInterface(player.inventory, inv); + } + }), + + DUAL_INTERFACE_FLUID(new TileGuiFactory(TileFluidInterface.class) { + @Override + protected Object createServerGui(EntityPlayer player, TileFluidInterface inv) { + return new ContainerFluidInterface(player.inventory, inv); + } + + @Override + protected Object createClientGui(EntityPlayer player, TileFluidInterface inv) { + return new GuiFluidInterface(player.inventory, inv); + } + }), + + DUAL_INTERFACE_PRIORITY(new TileGuiFactory(IPriorityHost.class) { + @Override + protected Object createServerGui(EntityPlayer player, IPriorityHost inv) { + return new ContainerPriority(player.inventory, inv); + } + + @Override + protected Object createClientGui(EntityPlayer player, IPriorityHost inv) { + return new GuiFCPriority(player.inventory, inv); + } + }), + FLUID_BUS_IO(new PartGuiFactory(PartSharedFluidBus.class) { @Override protected Object createServerGui(EntityPlayer player, PartSharedFluidBus inv) { diff --git a/src/main/java/com/glodblock/github/inventory/gui/MouseRegionManager.java b/src/main/java/com/glodblock/github/inventory/gui/MouseRegionManager.java index 06107e85..313e2368 100644 --- a/src/main/java/com/glodblock/github/inventory/gui/MouseRegionManager.java +++ b/src/main/java/com/glodblock/github/inventory/gui/MouseRegionManager.java @@ -1,6 +1,5 @@ package com.glodblock.github.inventory.gui; -import com.glodblock.github.util.Ae2Reflect; import com.glodblock.github.util.Ae2ReflectClient; import net.minecraft.client.audio.PositionedSoundRecord; import net.minecraft.client.gui.inventory.GuiContainer; diff --git a/src/main/java/com/glodblock/github/inventory/slot/OptionalFluidSlotFakeTypeOnly.java b/src/main/java/com/glodblock/github/inventory/slot/OptionalFluidSlotFakeTypeOnly.java index 6986f82a..05b1bfe4 100644 --- a/src/main/java/com/glodblock/github/inventory/slot/OptionalFluidSlotFakeTypeOnly.java +++ b/src/main/java/com/glodblock/github/inventory/slot/OptionalFluidSlotFakeTypeOnly.java @@ -19,8 +19,7 @@ public class OptionalFluidSlotFakeTypeOnly extends OptionalSlotFakeTypeOnly { { FluidStack fluidStack = Util.getFluidFromItem(is); if (fluidStack != null) { - ItemStack tmp = ItemFluidPacket.newStack(fluidStack); - tmp.setStackDisplayName(fluidStack.getLocalizedName()); + ItemStack tmp = ItemFluidPacket.newDisplayStack(fluidStack); super.putStack(tmp); } else { diff --git a/src/main/java/com/glodblock/github/loader/ChannelLoader.java b/src/main/java/com/glodblock/github/loader/ChannelLoader.java index 9b7cee71..9073ec55 100644 --- a/src/main/java/com/glodblock/github/loader/ChannelLoader.java +++ b/src/main/java/com/glodblock/github/loader/ChannelLoader.java @@ -20,6 +20,5 @@ public class ChannelLoader implements Runnable { FluidCraft.proxy.netHandler.registerMessage(new CPacketTransferRecipe.Handler(), CPacketTransferRecipe.class, id ++, Side.SERVER); FluidCraft.proxy.netHandler.registerMessage(new CPacketDumpTank.Handler(), CPacketDumpTank.class, id ++, Side.SERVER); FluidCraft.proxy.netHandler.registerMessage(new SPacketFluidUpdate.Handler(), SPacketFluidUpdate.class, id ++, Side.CLIENT); - FluidCraft.proxy.netHandler.registerMessage(new CPacketFluidUpdate.Handler(), CPacketFluidUpdate.class, id ++, Side.SERVER); } } diff --git a/src/main/java/com/glodblock/github/network/CPacketFluidUpdate.java b/src/main/java/com/glodblock/github/network/CPacketFluidUpdate.java deleted file mode 100644 index 91766ff5..00000000 --- a/src/main/java/com/glodblock/github/network/CPacketFluidUpdate.java +++ /dev/null @@ -1,80 +0,0 @@ -package com.glodblock.github.network; - -import appeng.api.storage.data.IAEFluidStack; -import appeng.util.item.AEFluidStack; -import com.glodblock.github.client.gui.container.ContainerFluidConfigurable; -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.inventory.Container; - -import java.io.IOException; -import java.util.HashMap; -import java.util.Map; - -public class CPacketFluidUpdate implements IMessage { - - private Map list; - - public CPacketFluidUpdate() { - } - - public CPacketFluidUpdate(Map data) { - this.list = data; - } - - @Override - public void fromBytes(ByteBuf buf) { - int size = buf.readInt(); - this.list = new HashMap<>(); - try { - for (int i = 0; i < size; i ++) { - int id = buf.readInt(); - boolean isNull = buf.readBoolean(); - if (!isNull) - list.put(id, null); - else { - IAEFluidStack fluid = AEFluidStack.loadFluidStackFromPacket(buf); - list.put(id, fluid); - } - } - } catch (IOException e) { - e.printStackTrace(); - } - } - - @Override - public void toBytes(ByteBuf buf) { - buf.writeInt(list.size()); - try { - for (Map.Entry fs : list.entrySet()) { - buf.writeInt(fs.getKey()); - if (fs.getValue() == null) - buf.writeBoolean(false); - else { - buf.writeBoolean(true); - fs.getValue().writeToPacket(buf); - } - } - } catch (IOException e) { - e.printStackTrace(); - } - } - - public static class Handler implements IMessageHandler { - - @Override - public IMessage onMessage(CPacketFluidUpdate message, MessageContext ctx) { - final Container c = ctx.getServerHandler().playerEntity.openContainer; - if( c instanceof ContainerFluidConfigurable) - { - for (Map.Entry e : message.list.entrySet() ) { - ( (ContainerFluidConfigurable) c ).setFluid(e.getKey(), e.getValue()); - } - } - return null; - } - - } -} diff --git a/src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java b/src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java index 3316626b..bf371e7e 100644 --- a/src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java +++ b/src/main/java/com/glodblock/github/network/SPacketFluidUpdate.java @@ -3,6 +3,7 @@ package com.glodblock.github.network; import appeng.api.storage.data.IAEFluidStack; import appeng.util.item.AEFluidStack; import com.glodblock.github.client.gui.GuiFluidIO; +import com.glodblock.github.client.gui.GuiFluidInterface; import com.glodblock.github.client.gui.GuiIngredientBuffer; import cpw.mods.fml.common.network.simpleimpl.IMessage; import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; @@ -79,6 +80,10 @@ public class SPacketFluidUpdate implements IMessage { for (Map.Entry e : message.list.entrySet() ) { ( (GuiFluidIO) gs ).update(e.getKey(), e.getValue()); } + } else if (gs instanceof GuiFluidInterface) { + for (Map.Entry e : message.list.entrySet() ) { + ( (GuiFluidInterface) gs ).update(e.getKey(), e.getValue()); + } } return null; } diff --git a/src/main/java/com/glodblock/github/util/NameConst.java b/src/main/java/com/glodblock/github/util/NameConst.java index e0f01687..af7dec7a 100644 --- a/src/main/java/com/glodblock/github/util/NameConst.java +++ b/src/main/java/com/glodblock/github/util/NameConst.java @@ -36,5 +36,6 @@ public class NameConst { public static final String GUI_FLUID_PATTERN_ENCODER = GUI_KEY + BLOCK_FLUID_PATTERN_ENCODER; public static final String GUI_FLUID_PACKET_DECODER = GUI_KEY + BLOCK_FLUID_PACKET_DECODER; public static final String GUI_INGREDIENT_BUFFER = GUI_KEY + BLOCK_INGREDIENT_BUFFER; + public static final String GUI_FLUID_INTERFACE = GUI_KEY + BLOCK_FLUID_INTERFACE; } diff --git a/src/main/java/com/glodblock/github/util/Util.java b/src/main/java/com/glodblock/github/util/Util.java index 4596c795..b4b0d0cf 100644 --- a/src/main/java/com/glodblock/github/util/Util.java +++ b/src/main/java/com/glodblock/github/util/Util.java @@ -116,4 +116,9 @@ public final class Util { return fluid; } + public static boolean areFluidsEqual(FluidStack fluid1, FluidStack fluid2) { + if (fluid1 == null || fluid2 == null) return false; + return fluid1.isFluidEqual(fluid2); + } + } diff --git a/src/main/resources/assets/ae2fc/lang/en_US.lang b/src/main/resources/assets/ae2fc/lang/en_US.lang index 26f2ccae..2d67f29a 100644 --- a/src/main/resources/assets/ae2fc/lang/en_US.lang +++ b/src/main/resources/assets/ae2fc/lang/en_US.lang @@ -32,9 +32,11 @@ ae2fc.tooltip.encode_pattern=Encode Patter ae2fc.tooltip.fluid_packet=Use a Fluid Packet Decoder to\nconvert this back into fluid. ae2fc.tooltip.empty=Empty ae2fc.tooltip.dump_tank=Dump Tank Contents +ae2fc.tooltip.switch_fluid_interface=Switch ME Dual Interface GUI ae2fc.gui.part_fluid_pattern_terminal=Fluid Pattern Terminal ae2fc.gui.part_fluid_pattern_terminal_ex=Fluid Processing Pattern Terminal ae2fc.gui.fluid_pattern_encoder=Fluid Pattern Encoder ae2fc.gui.fluid_packet_decoder=ME Fluid Packet Decoder ae2fc.gui.ingredient_buffer=Ingredient Buffer +ae2fc.gui.fluid_interface=ME Dual Interface diff --git a/src/main/resources/assets/ae2fc/textures/gui/interface_fluid.png b/src/main/resources/assets/ae2fc/textures/gui/interface_fluid.png new file mode 100644 index 00000000..41ed69fd Binary files /dev/null and b/src/main/resources/assets/ae2fc/textures/gui/interface_fluid.png differ