From 87f5bbcde2500c97565d3391fc436eaf7a31f317 Mon Sep 17 00:00:00 2001 From: "Aidan C. Brady" Date: Tue, 19 Nov 2013 17:39:16 -0500 Subject: [PATCH] Work on networking and GUIs of Digital Miner --- .../mekanism/client/gui/GuiDigitalMiner.java | 63 ++- .../client/gui/GuiDigitalMinerConfig.java | 475 +++++++++++++++++- .../client/gui/GuiMItemStackFilter.java | 229 +++++++++ .../client/gui/GuiMOreDictFilter.java | 349 +++++++++++++ ...ckFilter.java => GuiTItemStackFilter.java} | 6 +- ...DictFilter.java => GuiTOreDictFilter.java} | 6 +- common/mekanism/common/Mekanism.java | 2 + .../container/ContainerDigitalMiner.java | 1 - .../inventory/container/ContainerFilter.java | 6 - .../common/network/PacketDigitalMinerGui.java | 213 ++++++++ .../common/network/PacketEditFilter.java | 134 +++-- .../network/PacketLogisticalSorterGui.java | 12 +- .../common/network/PacketNewFilter.java | 65 ++- .../tileentity/TileEntityDigitalMiner.java | 61 ++- 14 files changed, 1560 insertions(+), 62 deletions(-) create mode 100644 common/mekanism/client/gui/GuiMItemStackFilter.java create mode 100644 common/mekanism/client/gui/GuiMOreDictFilter.java rename common/mekanism/client/gui/{GuiItemStackFilter.java => GuiTItemStackFilter.java} (97%) rename common/mekanism/client/gui/{GuiOreDictFilter.java => GuiTOreDictFilter.java} (97%) create mode 100644 common/mekanism/common/network/PacketDigitalMinerGui.java diff --git a/common/mekanism/client/gui/GuiDigitalMiner.java b/common/mekanism/client/gui/GuiDigitalMiner.java index 5fbfe032b..4c568e644 100644 --- a/common/mekanism/client/gui/GuiDigitalMiner.java +++ b/common/mekanism/client/gui/GuiDigitalMiner.java @@ -1,5 +1,66 @@ package mekanism.client.gui; -public class GuiDigitalMiner { +import mekanism.common.inventory.container.ContainerDigitalMiner; +import mekanism.common.tileentity.TileEntityDigitalMiner; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import net.minecraft.entity.player.InventoryPlayer; +import org.lwjgl.opengl.GL11; + +import universalelectricity.core.electricity.ElectricityDisplay; +import universalelectricity.core.electricity.ElectricityDisplay.ElectricUnit; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiDigitalMiner extends GuiMekanism +{ + public TileEntityDigitalMiner tileEntity; + + public GuiDigitalMiner(InventoryPlayer inventory, TileEntityDigitalMiner tentity) + { + super(new ContainerDigitalMiner(inventory, tentity)); + tileEntity = tentity; + + guiElements.add(new GuiRedstoneControl(this, tileEntity, MekanismUtils.getResource(ResourceType.GUI, "GuiDigitalMiner.png"))); + guiElements.add(new GuiUpgradeManagement(this, tileEntity, MekanismUtils.getResource(ResourceType.GUI, "GuiDigitalMiner.png"))); + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + fontRenderer.drawString(tileEntity.fullName, 45, 6, 0x404040); + fontRenderer.drawString("Inventory", 8, (ySize - 96) + 2, 0x404040); + + if(xAxis >= 165 && xAxis <= 169 && yAxis >= 17 && yAxis <= 69) + { + drawCreativeTabHoveringText(ElectricityDisplay.getDisplayShort(tileEntity.getEnergyStored(), ElectricUnit.JOULES), xAxis, yAxis); + } +} + +@Override +protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) +{ + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiDigitalMiner.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize); + + int xAxis = mouseX - guiWidth; + int yAxis = mouseY - guiHeight; + + int displayInt; + + displayInt = tileEntity.getScaledEnergyLevel(52); + drawTexturedModalRect(guiWidth + 165, guiHeight + 17 + 52 - displayInt, 176, 7 + 52 - displayInt, 4, displayInt); +} } diff --git a/common/mekanism/client/gui/GuiDigitalMinerConfig.java b/common/mekanism/client/gui/GuiDigitalMinerConfig.java index b589ef078..971613fc4 100644 --- a/common/mekanism/client/gui/GuiDigitalMinerConfig.java +++ b/common/mekanism/client/gui/GuiDigitalMinerConfig.java @@ -1,6 +1,477 @@ package mekanism.client.gui; -public class GuiDigitalMinerConfig -{ +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import mekanism.api.Object3D; +import mekanism.common.PacketHandler; +import mekanism.common.PacketHandler.Transmission; +import mekanism.common.inventory.container.ContainerNull; +import mekanism.common.miner.MItemStackFilter; +import mekanism.common.miner.MOreDictFilter; +import mekanism.common.miner.MinerFilter; +import mekanism.common.network.PacketLogisticalSorterGui; +import mekanism.common.network.PacketLogisticalSorterGui.SorterGuiPacket; +import mekanism.common.network.PacketTileEntity; +import mekanism.common.tileentity.TileEntityDigitalMiner; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.lwjgl.opengl.GL11; + +public class GuiDigitalMinerConfig extends GuiMekanism +{ + public TileEntityDigitalMiner tileEntity; + + public boolean isDragging = false; + + public int dragOffset = 0; + + public int stackSwitch = 0; + + public Map oreDictStacks = new HashMap(); + + public float scroll; + + public GuiDigitalMinerConfig(EntityPlayer player, TileEntityDigitalMiner tentity) + { + super(new ContainerNull(player, tentity)); + tileEntity = tentity; + } + + public int getScroll() + { + return Math.max(Math.min((int)(scroll*123), 123), 0); + } + + public int getFilterIndex() + { + if(tileEntity.filters.size() <= 4) + { + return 0; + } + + return (int)((tileEntity.filters.size()*scroll) - ((4F/(float)tileEntity.filters.size()))*scroll); + } + + @Override + public void updateScreen() + { + super.updateScreen(); + + if(stackSwitch > 0) + { + stackSwitch--; + } + + if(stackSwitch == 0) + { + for(Map.Entry entry : oreDictStacks.entrySet()) + { + if(entry.getValue().iterStacks != null && entry.getValue().iterStacks.size() > 0) + { + if(entry.getValue().stackIndex == -1 || entry.getValue().stackIndex == entry.getValue().iterStacks.size()-1) + { + entry.getValue().stackIndex = 0; + } + else if(entry.getValue().stackIndex < entry.getValue().iterStacks.size()-1) + { + entry.getValue().stackIndex++; + } + + entry.getValue().renderStack = entry.getValue().iterStacks.get(entry.getValue().stackIndex); + } + } + + stackSwitch = 20; + } + else { + for(Map.Entry entry : oreDictStacks.entrySet()) + { + if(entry.getValue().iterStacks != null && entry.getValue().iterStacks.size() == 0) + { + entry.getValue().renderStack = null; + } + } + } + + Set filtersVisible = new HashSet(); + + for(int i = 0; i < 4; i++) + { + if(tileEntity.filters.get(getFilterIndex()+i) instanceof MOreDictFilter) + { + filtersVisible.add((MOreDictFilter)tileEntity.filters.get(getFilterIndex()+i)); + } + } + + for(MinerFilter filter : tileEntity.filters) + { + if(filter instanceof MOreDictFilter && !filtersVisible.contains(filter)) + { + if(oreDictStacks.containsKey(filter)) + { + oreDictStacks.remove(filter); + } + } + } + } + + @Override + public void mouseClicked(int mouseX, int mouseY, int button) + { + super.mouseClicked(mouseX, mouseY, button); + + if(button == 0) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(xAxis >= 154 && xAxis <= 166 && yAxis >= getScroll()+18 && yAxis <= getScroll()+18+15) + { + dragOffset = yAxis - (getScroll()+18); + isDragging = true; + } + + for(int i = 0; i < 4; i++) + { + if(tileEntity.filters.get(getFilterIndex()+i) != null) + { + int yStart = i*29 + 18; + + if(xAxis >= 56 && xAxis <= 152 && yAxis >= yStart && yAxis <= yStart+29) + { + MinerFilter filter = tileEntity.filters.get(getFilterIndex()+i); + + if(filter instanceof MItemStackFilter) + { + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER_INDEX, Object3D.get(tileEntity), 1, getFilterIndex()+i)); + } + else if(filter instanceof MOreDictFilter) + { + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER_INDEX, Object3D.get(tileEntity), 2, getFilterIndex()+i)); + } + } + } + } + + if(xAxis >= 13 && xAxis <= 29 && yAxis >= 137 && yAxis <= 153) + { + ArrayList data = new ArrayList(); + data.add(0); + + PacketHandler.sendPacket(Transmission.SERVER, new PacketTileEntity().setParams(Object3D.get(tileEntity), data)); + mc.sndManager.playSoundFX("mekanism:etc.Ding", 1.0F, 1.0F); + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 110 && yAxis <= 124) + { + ArrayList data = new ArrayList(); + data.add(1); + + PacketHandler.sendPacket(Transmission.SERVER, new PacketTileEntity().setParams(Object3D.get(tileEntity), data)); + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 84 && yAxis <= 98) + { + ArrayList data = new ArrayList(); + data.add(2); + + PacketHandler.sendPacket(Transmission.SERVER, new PacketTileEntity().setParams(Object3D.get(tileEntity), data)); + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + } + } + } + + @Override + protected void mouseClickMove(int mouseX, int mouseY, int button, long ticks) + { + super.mouseClickMove(mouseX, mouseY, button, ticks); + + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(isDragging) + { + scroll = Math.min(Math.max((float)(yAxis-18-dragOffset)/123F, 0), 1); + } + } + + @Override + protected void mouseMovedOrUp(int x, int y, int type) + { + super.mouseMovedOrUp(x, y, type); + + if(type == 0 && isDragging) + { + dragOffset = 0; + isDragging = false; + } + } + + @Override + public void initGui() + { + super.initGui(); + + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + + buttonList.clear(); + buttonList.add(new GuiButton(0, guiWidth + 56, guiHeight + 136, 54, 20, "ItemStack")); + buttonList.add(new GuiButton(1, guiWidth + 110, guiHeight + 136, 43, 20, "OreDict")); + } + + @Override + protected void actionPerformed(GuiButton guibutton) + { + super.actionPerformed(guibutton); + + if(guibutton.id == 0) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 1)); + } + else if(guibutton.id == 1) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 2)); + } + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + fontRenderer.drawString("Logistical Sorter", 43, 6, 0x404040); + + fontRenderer.drawString("Filters:", 11, 19, 0x00CD00); + fontRenderer.drawString("T: " + tileEntity.filters.size(), 11, 28, 0x00CD00); + fontRenderer.drawString("IS: " + getItemStackFilters().size(), 11, 37, 0x00CD00); + fontRenderer.drawString("OD: " + getOreDictFilters().size(), 11, 46, 0x00CD00); + + fontRenderer.drawString("Default:", 12, 126, 0x00CD00); + + for(int i = 0; i < 4; i++) + { + if(tileEntity.filters.get(getFilterIndex()+i) != null) + { + MinerFilter filter = tileEntity.filters.get(getFilterIndex()+i); + int yStart = i*29 + 18; + + if(filter instanceof MItemStackFilter) + { + MItemStackFilter itemFilter = (MItemStackFilter)filter; + + if(itemFilter.itemType != null) + { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_LIGHTING); + itemRenderer.renderItemAndEffectIntoGUI(fontRenderer, mc.getTextureManager(), itemFilter.itemType, 59, yStart + 3); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glPopMatrix(); + } + + fontRenderer.drawString("Item Filter", 78, yStart + 2, 0x404040); + } + else if(filter instanceof MOreDictFilter) + { + MOreDictFilter oreFilter = (MOreDictFilter)filter; + + if(!oreDictStacks.containsKey(oreFilter)) + { + updateStackList(oreFilter); + } + + if(oreDictStacks.get(filter).renderStack != null) + { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_LIGHTING); + itemRenderer.renderItemAndEffectIntoGUI(fontRenderer, mc.getTextureManager(), oreDictStacks.get(filter).renderStack, 59, yStart + 3); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glPopMatrix(); + } + + fontRenderer.drawString("OreDict Filter", 78, yStart + 2, 0x404040); + } + } + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 110 && yAxis <= 124) + { + drawCreativeTabHoveringText("Auto-eject", xAxis, yAxis); + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 84 && yAxis <= 98) + { + drawCreativeTabHoveringText("Round robin", xAxis, yAxis); + } + + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) + { + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiLogisticalSorter.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize); + + drawTexturedModalRect(guiWidth + 154, guiHeight + 18 + getScroll(), 232, 0, 12, 15); + + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + for(int i = 0; i < 4; i++) + { + if(tileEntity.filters.get(getFilterIndex()+i) != null) + { + MinerFilter filter = tileEntity.filters.get(getFilterIndex()+i); + int yStart = i*29 + 18; + + boolean mouseOver = xAxis >= 56 && xAxis <= 152 && yAxis >= yStart && yAxis <= yStart+29; + + if(filter instanceof MItemStackFilter) + { + drawTexturedModalRect(guiWidth + 56, guiHeight + yStart, mouseOver ? 0 : 96, 166, 96, 29); + } + else if(filter instanceof MOreDictFilter) + { + drawTexturedModalRect(guiWidth + 56, guiHeight + yStart, mouseOver ? 0 : 96, 195, 96, 29); + } + } + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 110 && yAxis <= 124) + { + drawTexturedModalRect(guiWidth + 12, guiHeight + 110, 176, 0, 14, 14); + } + else { + drawTexturedModalRect(guiWidth + 12, guiHeight + 110, 176, 14, 14, 14); + } + + if(xAxis >= 12 && xAxis <= 26 && yAxis >= 84 && yAxis <= 98) + { + drawTexturedModalRect(guiWidth + 12, guiHeight + 84, 176 + 14, 0, 14, 14); + } + else { + drawTexturedModalRect(guiWidth + 12, guiHeight + 84, 176 + 14, 14, 14, 14); + } + } + + public ArrayList getItemStackFilters() + { + ArrayList list = new ArrayList(); + + for(MinerFilter filter : tileEntity.filters) + { + if(filter instanceof MItemStackFilter) + { + list.add(filter); + } + } + + return list; + } + + public ArrayList getOreDictFilters() + { + ArrayList list = new ArrayList(); + + for(MinerFilter filter : tileEntity.filters) + { + if(filter instanceof MOreDictFilter) + { + list.add(filter); + } + } + + return list; + } + + private void updateStackList(MOreDictFilter filter) + { + if(!oreDictStacks.containsKey(filter)) + { + oreDictStacks.put(filter, new StackData()); + } + + if(oreDictStacks.get(filter).iterStacks == null) + { + oreDictStacks.get(filter).iterStacks = new ArrayList(); + } + else { + oreDictStacks.get(filter).iterStacks.clear(); + } + + List keys = new ArrayList(); + + for(String s : OreDictionary.getOreNames()) + { + if(filter.oreDictName.equals(s) || filter.oreDictName.equals("*")) + { + keys.add(s); + } + else if(filter.oreDictName.endsWith("*") && !filter.oreDictName.startsWith("*")) + { + if(s.startsWith(filter.oreDictName.substring(0, filter.oreDictName.length()-1))) + { + keys.add(s); + } + } + else if(filter.oreDictName.startsWith("*") && !filter.oreDictName.endsWith("*")) + { + if(s.endsWith(filter.oreDictName.substring(1))) + { + keys.add(s); + } + } + else if(filter.oreDictName.startsWith("*") && filter.oreDictName.endsWith("*")) + { + if(s.contains(filter.oreDictName.substring(1, filter.oreDictName.length()-1))) + { + keys.add(s); + } + } + } + + for(String key : keys) + { + for(ItemStack stack : OreDictionary.getOres(key)) + { + ItemStack toAdd = stack.copy(); + + if(!oreDictStacks.get(filter).iterStacks.contains(stack)) + { + oreDictStacks.get(filter).iterStacks.add(stack.copy()); + } + } + } + + stackSwitch = 0; + updateScreen(); + oreDictStacks.get(filter).stackIndex = -1; + } + + public static class StackData + { + public List iterStacks; + public int stackIndex; + public ItemStack renderStack; + } } diff --git a/common/mekanism/client/gui/GuiMItemStackFilter.java b/common/mekanism/client/gui/GuiMItemStackFilter.java new file mode 100644 index 000000000..e60c85743 --- /dev/null +++ b/common/mekanism/client/gui/GuiMItemStackFilter.java @@ -0,0 +1,229 @@ +package mekanism.client.gui; + +import mekanism.api.EnumColor; +import mekanism.api.Object3D; +import mekanism.client.render.MekanismRenderer; +import mekanism.common.PacketHandler; +import mekanism.common.PacketHandler.Transmission; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.common.miner.MItemStackFilter; +import mekanism.common.network.PacketEditFilter; +import mekanism.common.network.PacketLogisticalSorterGui; +import mekanism.common.network.PacketLogisticalSorterGui.SorterGuiPacket; +import mekanism.common.network.PacketNewFilter; +import mekanism.common.tileentity.TileEntityDigitalMiner; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import mekanism.common.util.TransporterUtils; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiTextField; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; + +public class GuiMItemStackFilter extends GuiMekanism +{ + public TileEntityDigitalMiner tileEntity; + + public boolean isNew = false; + + public MItemStackFilter origFilter; + + public MItemStackFilter filter = new MItemStackFilter(); + + public String status = EnumColor.DARK_GREEN + "All OK"; + + public int ticker; + + public GuiMItemStackFilter(EntityPlayer player, TileEntityDigitalMiner tentity, int index) + { + super(new ContainerFilter(player.inventory)); + tileEntity = tentity; + + origFilter = (MItemStackFilter)tileEntity.filters.get(index); + filter = ((MItemStackFilter)tileEntity.filters.get(index)).clone(); + } + + public GuiMItemStackFilter(EntityPlayer player, TileEntityDigitalMiner tentity) + { + super(new ContainerFilter(player.inventory)); + tileEntity = tentity; + + isNew = true; + } + + @Override + public void initGui() + { + super.initGui(); + + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + + buttonList.clear(); + buttonList.add(new GuiButton(0, guiWidth + 27, guiHeight + 62, 60, 20, "Save")); + buttonList.add(new GuiButton(1, guiWidth + 89, guiHeight + 62, 60, 20, "Delete")); + + if(isNew) + { + ((GuiButton)buttonList.get(1)).enabled = false; + } + } + + @Override + protected void actionPerformed(GuiButton guibutton) + { + super.actionPerformed(guibutton); + + if(guibutton.id == 0) + { + if(filter.itemType != null) + { + if(isNew) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketNewFilter().setParams(Object3D.get(tileEntity), filter)); + } + else { + PacketHandler.sendPacket(Transmission.SERVER, new PacketEditFilter().setParams(Object3D.get(tileEntity), false, origFilter, filter)); + } + + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + else if(filter.itemType == null) + { + status = EnumColor.DARK_RED + "No item"; + ticker = 20; + } + } + else if(guibutton.id == 1) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketEditFilter().setParams(Object3D.get(tileEntity), true, origFilter)); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + fontRenderer.drawString((isNew ? "New" : "Edit") + " Item Filter", 43, 6, 0x404040); + fontRenderer.drawString("Status: " + status, 35, 20, 0x00CD00); + fontRenderer.drawString("ItemStack Details:", 35, 32, 0x00CD00); + + if(filter.itemType != null) + { + fontRenderer.drawString("Item: " + filter.itemType.getDisplayName(), 35, 41, 0x00CD00); + } + + if(filter.itemType != null) + { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_LIGHTING); + itemRenderer.renderItemAndEffectIntoGUI(fontRenderer, mc.getTextureManager(), filter.itemType, 12, 19); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glPopMatrix(); + } + + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + } + + @Override + public void updateScreen() + { + super.updateScreen(); + + if(ticker > 0) + { + ticker--; + } + else { + status = EnumColor.DARK_GREEN + "All OK"; + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) + { + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiItemStackFilter.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize); + + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(xAxis >= 5 && xAxis <= 16 && yAxis >= 5 && yAxis <= 16) + { + drawTexturedModalRect(guiWidth + 5, guiHeight + 5, 176, 0, 11, 11); + } + else { + drawTexturedModalRect(guiWidth + 5, guiHeight + 5, 176, 11, 11, 11); + } + + if(xAxis >= 128 && xAxis <= 139 && yAxis >= 44 && yAxis <= 55) + { + drawTexturedModalRect(guiWidth + 128, guiHeight + 44, 187, 0, 11, 11); + } + else { + drawTexturedModalRect(guiWidth + 128, guiHeight + 44, 187, 11, 11, 11); + } + + if(xAxis >= 12 && xAxis <= 28 && yAxis >= 19 && yAxis <= 35) + { + GL11.glPushMatrix(); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glDisable(GL11.GL_DEPTH_TEST); + + int x = guiWidth + 12; + int y = guiHeight + 19; + drawGradientRect(x, y, x + 16, y + 16, -2130706433, -2130706433); + + GL11.glEnable(GL11.GL_LIGHTING); + GL11.glEnable(GL11.GL_DEPTH_TEST); + GL11.glPopMatrix(); + } + } + + @Override + protected void mouseClicked(int mouseX, int mouseY, int button) + { + super.mouseClicked(mouseX, mouseY, button); + + if(button == 0) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(xAxis >= 5 && xAxis <= 16 && yAxis >= 5 && yAxis <= 16) + { + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + + if(xAxis >= 12 && xAxis <= 28 && yAxis >= 19 && yAxis <= 35) + { + ItemStack stack = mc.thePlayer.inventory.getItemStack(); + + if(stack != null && !Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) + { + filter.itemType = stack.copy(); + filter.itemType.stackSize = 1; + } + else if(stack == null && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) + { + filter.itemType = null; + } + + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + } + } + } +} diff --git a/common/mekanism/client/gui/GuiMOreDictFilter.java b/common/mekanism/client/gui/GuiMOreDictFilter.java new file mode 100644 index 000000000..ab03e41f7 --- /dev/null +++ b/common/mekanism/client/gui/GuiMOreDictFilter.java @@ -0,0 +1,349 @@ +package mekanism.client.gui; + +import java.util.ArrayList; +import java.util.List; + +import mekanism.api.EnumColor; +import mekanism.api.Object3D; +import mekanism.common.PacketHandler; +import mekanism.common.PacketHandler.Transmission; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.common.miner.MOreDictFilter; +import mekanism.common.network.PacketEditFilter; +import mekanism.common.network.PacketLogisticalSorterGui; +import mekanism.common.network.PacketLogisticalSorterGui.SorterGuiPacket; +import mekanism.common.network.PacketNewFilter; +import mekanism.common.tileentity.TileEntityDigitalMiner; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiTextField; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; + +public class GuiMOreDictFilter extends GuiMekanism +{ + public TileEntityDigitalMiner tileEntity; + + public boolean isNew = false; + + public MOreDictFilter origFilter; + + public MOreDictFilter filter = new MOreDictFilter(); + + private GuiTextField oreDictText; + + public ItemStack renderStack; + + public int ticker = 0; + + public int stackSwitch = 0; + + public int stackIndex = 0; + + public List iterStacks; + + public String status = EnumColor.DARK_GREEN + "All OK"; + + public GuiMOreDictFilter(EntityPlayer player, TileEntityDigitalMiner tentity, int index) + { + super(new ContainerFilter(player.inventory)); + tileEntity = tentity; + + origFilter = (MOreDictFilter)tileEntity.filters.get(index); + filter = ((MOreDictFilter)tentity.filters.get(index)).clone(); + + updateStackList(filter.oreDictName); + } + + public GuiMOreDictFilter(EntityPlayer player, TileEntityDigitalMiner tentity) + { + super(new ContainerFilter(player.inventory)); + tileEntity = tentity; + + isNew = true; + } + + @Override + public void initGui() + { + super.initGui(); + + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + + buttonList.clear(); + buttonList.add(new GuiButton(0, guiWidth + 27, guiHeight + 62, 60, 20, "Save")); + buttonList.add(new GuiButton(1, guiWidth + 89, guiHeight + 62, 60, 20, "Delete")); + + if(isNew) + { + ((GuiButton)buttonList.get(1)).enabled = false; + } + + oreDictText = new GuiTextField(fontRenderer, guiWidth + 35, guiHeight + 47, 95, 12); + oreDictText.setMaxStringLength(12); + oreDictText.setFocused(true); + } + + @Override + public void keyTyped(char c, int i) + { + if(!oreDictText.isFocused() || i == Keyboard.KEY_ESCAPE) + { + super.keyTyped(c, i); + } + + if(oreDictText.isFocused() && i == Keyboard.KEY_RETURN) + { + setOreDictKey(); + return; + } + + if(Character.isLetter(c) || Character.isDigit(c) || c == '*' || i == Keyboard.KEY_BACK || i == Keyboard.KEY_DELETE || i == Keyboard.KEY_LEFT || i == Keyboard.KEY_RIGHT) + { + oreDictText.textboxKeyTyped(c, i); + } + } + + @Override + protected void actionPerformed(GuiButton guibutton) + { + super.actionPerformed(guibutton); + + if(guibutton.id == 0) + { + if(!oreDictText.getText().isEmpty()) + { + setOreDictKey(); + } + + if(filter.oreDictName != null && !filter.oreDictName.isEmpty()) + { + if(isNew) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketNewFilter().setParams(Object3D.get(tileEntity), filter)); + } + else { + PacketHandler.sendPacket(Transmission.SERVER, new PacketEditFilter().setParams(Object3D.get(tileEntity), false, origFilter, filter)); + } + + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + else { + status = EnumColor.DARK_RED + "No key"; + ticker = 20; + } + } + else if(guibutton.id == 1) + { + PacketHandler.sendPacket(Transmission.SERVER, new PacketEditFilter().setParams(Object3D.get(tileEntity), true, origFilter)); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + fontRenderer.drawString((isNew ? "New" : "Edit") + " OreDict Filter", 43, 6, 0x404040); + fontRenderer.drawString("Status: " + status, 35, 20, 0x00CD00); + fontRenderer.drawString("Key: " + filter.oreDictName, 35, 32, 0x00CD00); + + if(renderStack != null) + { + GL11.glPushMatrix(); + GL11.glEnable(GL11.GL_LIGHTING); + itemRenderer.renderItemAndEffectIntoGUI(fontRenderer, mc.getTextureManager(), renderStack, 12, 19); + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glPopMatrix(); + } + + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) + { + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + + mc.renderEngine.bindTexture(MekanismUtils.getResource(ResourceType.GUI, "GuiOreDictFilter.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + drawTexturedModalRect(guiWidth, guiHeight, 0, 0, xSize, ySize); + + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(xAxis >= 5 && xAxis <= 16 && yAxis >= 5 && yAxis <= 16) + { + drawTexturedModalRect(guiWidth + 5, guiHeight + 5, 176, 0, 11, 11); + } + else { + drawTexturedModalRect(guiWidth + 5, guiHeight + 5, 176, 11, 11, 11); + } + + if(xAxis >= 131 && xAxis <= 143 && yAxis >= 47 && yAxis <= 59) + { + drawTexturedModalRect(guiWidth + 131, guiHeight + 47, 176 + 11, 0, 12, 12); + } + else { + drawTexturedModalRect(guiWidth + 131, guiHeight + 47, 176 + 11, 12, 12, 12); + } + + oreDictText.drawTextBox(); + } + + @Override + public void updateScreen() + { + super.updateScreen(); + + oreDictText.updateCursorCounter(); + + if(ticker > 0) + { + ticker--; + } + else { + status = EnumColor.DARK_GREEN + "All OK"; + } + + if(stackSwitch > 0) + { + stackSwitch--; + } + + if(stackSwitch == 0 && iterStacks != null && iterStacks.size() > 0) + { + stackSwitch = 20; + + if(stackIndex == -1 || stackIndex == iterStacks.size()-1) + { + stackIndex = 0; + } + else if(stackIndex < iterStacks.size()-1) + { + stackIndex++; + } + + renderStack = iterStacks.get(stackIndex); + } + else if(iterStacks != null && iterStacks.size() == 0) + { + renderStack = null; + } + } + + @Override + protected void mouseClicked(int mouseX, int mouseY, int button) + { + super.mouseClicked(mouseX, mouseY, button); + + oreDictText.mouseClicked(mouseX, mouseY, button); + + if(button == 0) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(xAxis >= 5 && xAxis <= 16 && yAxis >= 5 && yAxis <= 16) + { + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + PacketHandler.sendPacket(Transmission.SERVER, new PacketLogisticalSorterGui().setParams(SorterGuiPacket.SERVER, Object3D.get(tileEntity), 0)); + } + + if(xAxis >= 131 && xAxis <= 143 && yAxis >= 47 && yAxis <= 59) + { + mc.sndManager.playSoundFX("random.click", 1.0F, 1.0F); + setOreDictKey(); + } + } + } + + private void updateStackList(String oreName) + { + if(iterStacks == null) + { + iterStacks = new ArrayList(); + } + else { + iterStacks.clear(); + } + + List keys = new ArrayList(); + + for(String s : OreDictionary.getOreNames()) + { + if(oreName.equals(s) || oreName.equals("*")) + { + keys.add(s); + } + else if(oreName.endsWith("*") && !oreName.startsWith("*")) + { + if(s.startsWith(oreName.substring(0, oreName.length()-1))) + { + keys.add(s); + } + } + else if(oreName.startsWith("*") && !oreName.endsWith("*")) + { + if(s.endsWith(oreName.substring(1))) + { + keys.add(s); + } + } + else if(oreName.startsWith("*") && oreName.endsWith("*")) + { + if(s.contains(oreName.substring(1, oreName.length()-1))) + { + keys.add(s); + } + } + } + + for(String key : keys) + { + for(ItemStack stack : OreDictionary.getOres(key)) + { + ItemStack toAdd = stack.copy(); + + if(!iterStacks.contains(stack)) + { + iterStacks.add(stack.copy()); + } + } + } + + stackSwitch = 0; + stackIndex = -1; + } + + private void setOreDictKey() + { + String oreName = oreDictText.getText(); + + if(oreName == null || oreName.isEmpty()) + { + status = EnumColor.DARK_RED + "No key entered"; + return; + } + else if(oreName.equals(filter.oreDictName)) + { + status = EnumColor.DARK_RED + "Same key"; + return; + } + + updateStackList(oreName); + + filter.oreDictName = oreName; + oreDictText.setText(""); + } +} diff --git a/common/mekanism/client/gui/GuiItemStackFilter.java b/common/mekanism/client/gui/GuiTItemStackFilter.java similarity index 97% rename from common/mekanism/client/gui/GuiItemStackFilter.java rename to common/mekanism/client/gui/GuiTItemStackFilter.java index 7c75d8d3f..a92f5029e 100644 --- a/common/mekanism/client/gui/GuiItemStackFilter.java +++ b/common/mekanism/client/gui/GuiTItemStackFilter.java @@ -24,7 +24,7 @@ import org.lwjgl.input.Keyboard; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL12; -public class GuiItemStackFilter extends GuiMekanism +public class GuiTItemStackFilter extends GuiMekanism { public TileEntityLogisticalSorter tileEntity; @@ -41,7 +41,7 @@ public class GuiItemStackFilter extends GuiMekanism private GuiTextField minField; private GuiTextField maxField; - public GuiItemStackFilter(EntityPlayer player, TileEntityLogisticalSorter tentity, int index) + public GuiTItemStackFilter(EntityPlayer player, TileEntityLogisticalSorter tentity, int index) { super(new ContainerFilter(player.inventory)); tileEntity = tentity; @@ -50,7 +50,7 @@ public class GuiItemStackFilter extends GuiMekanism filter = ((TItemStackFilter)tileEntity.filters.get(index)).clone(); } - public GuiItemStackFilter(EntityPlayer player, TileEntityLogisticalSorter tentity) + public GuiTItemStackFilter(EntityPlayer player, TileEntityLogisticalSorter tentity) { super(new ContainerFilter(player.inventory)); tileEntity = tentity; diff --git a/common/mekanism/client/gui/GuiOreDictFilter.java b/common/mekanism/client/gui/GuiTOreDictFilter.java similarity index 97% rename from common/mekanism/client/gui/GuiOreDictFilter.java rename to common/mekanism/client/gui/GuiTOreDictFilter.java index 48b5efcea..cae1e74ed 100644 --- a/common/mekanism/client/gui/GuiOreDictFilter.java +++ b/common/mekanism/client/gui/GuiTOreDictFilter.java @@ -30,7 +30,7 @@ import org.lwjgl.input.Keyboard; import org.lwjgl.opengl.GL11; import org.lwjgl.opengl.GL12; -public class GuiOreDictFilter extends GuiMekanism +public class GuiTOreDictFilter extends GuiMekanism { public TileEntityLogisticalSorter tileEntity; @@ -54,7 +54,7 @@ public class GuiOreDictFilter extends GuiMekanism public String status = EnumColor.DARK_GREEN + "All OK"; - public GuiOreDictFilter(EntityPlayer player, TileEntityLogisticalSorter tentity, int index) + public GuiTOreDictFilter(EntityPlayer player, TileEntityLogisticalSorter tentity, int index) { super(new ContainerFilter(player.inventory)); tileEntity = tentity; @@ -65,7 +65,7 @@ public class GuiOreDictFilter extends GuiMekanism updateStackList(filter.oreDictName); } - public GuiOreDictFilter(EntityPlayer player, TileEntityLogisticalSorter tentity) + public GuiTOreDictFilter(EntityPlayer player, TileEntityLogisticalSorter tentity) { super(new ContainerFilter(player.inventory)); tileEntity = tentity; diff --git a/common/mekanism/common/Mekanism.java b/common/mekanism/common/Mekanism.java index 55c87f019..e414b1039 100644 --- a/common/mekanism/common/Mekanism.java +++ b/common/mekanism/common/Mekanism.java @@ -58,6 +58,7 @@ import mekanism.common.network.PacketConfigurationUpdate; import mekanism.common.network.PacketConfiguratorState; import mekanism.common.network.PacketDataRequest; import mekanism.common.network.PacketDigitUpdate; +import mekanism.common.network.PacketDigitalMinerGui; import mekanism.common.network.PacketEditFilter; import mekanism.common.network.PacketElectricBowState; import mekanism.common.network.PacketElectricChest; @@ -1137,6 +1138,7 @@ public class Mekanism PacketHandler.registerPacket(PacketEditFilter.class); PacketHandler.registerPacket(PacketConfigurationUpdate.class); PacketHandler.registerPacket(PacketSimpleGui.class); + PacketHandler.registerPacket(PacketDigitalMinerGui.class); //Donators donators.add("mrgreaper"); diff --git a/common/mekanism/common/inventory/container/ContainerDigitalMiner.java b/common/mekanism/common/inventory/container/ContainerDigitalMiner.java index 7da6ae99e..4c3336d17 100644 --- a/common/mekanism/common/inventory/container/ContainerDigitalMiner.java +++ b/common/mekanism/common/inventory/container/ContainerDigitalMiner.java @@ -53,7 +53,6 @@ public class ContainerDigitalMiner extends Container { super.onContainerClosed(entityplayer); - tileEntity.closeChest(); tileEntity.playersUsing.remove(entityplayer); } diff --git a/common/mekanism/common/inventory/container/ContainerFilter.java b/common/mekanism/common/inventory/container/ContainerFilter.java index 30a8bdcd2..061184449 100644 --- a/common/mekanism/common/inventory/container/ContainerFilter.java +++ b/common/mekanism/common/inventory/container/ContainerFilter.java @@ -28,12 +28,6 @@ public class ContainerFilter extends Container addSlotToContainer(new Slot(inventory, slotX, 8 + slotX * 18, 142)); } } - - @Override - public void onContainerClosed(EntityPlayer entityplayer) - { - super.onContainerClosed(entityplayer); - } @Override public boolean canInteractWith(EntityPlayer entityplayer) diff --git a/common/mekanism/common/network/PacketDigitalMinerGui.java b/common/mekanism/common/network/PacketDigitalMinerGui.java new file mode 100644 index 000000000..a9b73c072 --- /dev/null +++ b/common/mekanism/common/network/PacketDigitalMinerGui.java @@ -0,0 +1,213 @@ +package mekanism.common.network; + +import java.io.DataOutputStream; + +import mekanism.api.Object3D; +import mekanism.client.gui.GuiDigitalMiner; +import mekanism.client.gui.GuiMItemStackFilter; +import mekanism.client.gui.GuiMOreDictFilter; +import mekanism.common.PacketHandler; +import mekanism.common.PacketHandler.Transmission; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.common.inventory.container.ContainerNull; +import mekanism.common.tileentity.TileEntityContainerBlock; +import mekanism.common.tileentity.TileEntityDigitalMiner; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.Container; +import net.minecraft.world.World; + +import com.google.common.io.ByteArrayDataInput; + +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class PacketDigitalMinerGui implements IMekanismPacket +{ + public Object3D object3D; + + public MinerGuiPacket packetType; + + public int type; + + public int windowId = -1; + + public int index = -1; + + @Override + public String getName() + { + return "DigitalMinerGui"; + } + + @Override + public IMekanismPacket setParams(Object... data) + { + packetType = (MinerGuiPacket)data[0]; + + object3D = (Object3D)data[1]; + type = (Integer)data[2]; + + if(packetType == MinerGuiPacket.CLIENT) + { + windowId = (Integer)data[3]; + } + else if(packetType == MinerGuiPacket.SERVER_INDEX) + { + index = (Integer)data[3]; + } + else if(packetType == MinerGuiPacket.CLIENT_INDEX) + { + windowId = (Integer)data[3]; + index = (Integer)data[4]; + } + + return this; + } + + @Override + public void read(ByteArrayDataInput dataStream, EntityPlayer player, World world) throws Exception + { + packetType = MinerGuiPacket.values()[dataStream.readInt()]; + + object3D = new Object3D(dataStream.readInt(), dataStream.readInt(), dataStream.readInt(), dataStream.readInt()); + + type = dataStream.readInt(); + + if(packetType == MinerGuiPacket.CLIENT || packetType == MinerGuiPacket.CLIENT_INDEX) + { + windowId = dataStream.readInt(); + } + + if(packetType == MinerGuiPacket.SERVER_INDEX || packetType == MinerGuiPacket.CLIENT_INDEX) + { + index = dataStream.readInt(); + } + + if(!world.isRemote) + { + World worldServer = FMLCommonHandler.instance().getMinecraftServerInstance().worldServerForDimension(object3D.dimensionId); + + if(worldServer != null && object3D.getTileEntity(worldServer) instanceof TileEntityDigitalMiner) + { + openServerGui(packetType, type, worldServer, (EntityPlayerMP)player, object3D, index); + } + } + else { + if(object3D.getTileEntity(world) instanceof TileEntityDigitalMiner) + { + try { + if(packetType == MinerGuiPacket.CLIENT) + { + FMLCommonHandler.instance().showGuiScreen(getGui(packetType, type, player, world, object3D.xCoord, object3D.yCoord, object3D.zCoord, -1)); + } + else if(packetType == MinerGuiPacket.CLIENT_INDEX) + { + FMLCommonHandler.instance().showGuiScreen(getGui(packetType, type, player, world, object3D.xCoord, object3D.yCoord, object3D.zCoord, index)); + } + + player.openContainer.windowId = windowId; + } catch(Exception e) { + e.printStackTrace(); + } + } + } + } + + public static void openServerGui(MinerGuiPacket t, int guiType, World world, EntityPlayerMP playerMP, Object3D obj, int i) + { + Container container = null; + + if(guiType == 0) + { + container = new ContainerNull(playerMP, (TileEntityContainerBlock)obj.getTileEntity(world)); + } + else if(guiType == 1 || guiType == 2) + { + container = new ContainerFilter(playerMP.inventory); + } + + playerMP.incrementWindowID(); + playerMP.closeContainer(); + int window = playerMP.currentWindowId; + + if(t == MinerGuiPacket.SERVER) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketDigitalMinerGui().setParams(MinerGuiPacket.CLIENT, obj, guiType, window), playerMP); + } + else if(t == MinerGuiPacket.SERVER_INDEX) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketDigitalMinerGui().setParams(MinerGuiPacket.CLIENT_INDEX, obj, guiType, window, i), playerMP); + } + + playerMP.openContainer = container; + playerMP.openContainer.windowId = window; + playerMP.openContainer.addCraftingToCrafters(playerMP); + } + + @SideOnly(Side.CLIENT) + public GuiScreen getGui(MinerGuiPacket packetType, int type, EntityPlayer player, World world, int x, int y, int z, int index) + { + if(type == 0) + { + return new GuiDigitalMiner(player.inventory, (TileEntityDigitalMiner)world.getBlockTileEntity(x, y, z)); + } + else { + if(packetType == MinerGuiPacket.CLIENT) + { + if(type == 1) + { + return new GuiMItemStackFilter(player, (TileEntityDigitalMiner)world.getBlockTileEntity(x, y, z)); + } + else if(type == 2) + { + return new GuiMOreDictFilter(player, (TileEntityDigitalMiner)world.getBlockTileEntity(x, y, z)); + } + } + else if(packetType == MinerGuiPacket.CLIENT_INDEX) + { + if(type == 1) + { + return new GuiMItemStackFilter(player, (TileEntityDigitalMiner)world.getBlockTileEntity(x, y, z), index); + } + else if(type == 2) + { + return new GuiMOreDictFilter(player, (TileEntityDigitalMiner)world.getBlockTileEntity(x, y, z), index); + } + } + } + + return null; + } + + @Override + public void write(DataOutputStream dataStream) throws Exception + { + dataStream.writeInt(packetType.ordinal()); + + dataStream.writeInt(object3D.xCoord); + dataStream.writeInt(object3D.yCoord); + dataStream.writeInt(object3D.zCoord); + + dataStream.writeInt(object3D.dimensionId); + + dataStream.writeInt(type); + + if(packetType == MinerGuiPacket.CLIENT || packetType == MinerGuiPacket.CLIENT_INDEX) + { + dataStream.writeInt(windowId); + } + + if(packetType == MinerGuiPacket.SERVER_INDEX || packetType == MinerGuiPacket.CLIENT_INDEX) + { + dataStream.writeInt(index); + } + } + + public static enum MinerGuiPacket + { + SERVER, CLIENT, SERVER_INDEX, CLIENT_INDEX + } +} diff --git a/common/mekanism/common/network/PacketEditFilter.java b/common/mekanism/common/network/PacketEditFilter.java index 71481c228..a11350a5b 100644 --- a/common/mekanism/common/network/PacketEditFilter.java +++ b/common/mekanism/common/network/PacketEditFilter.java @@ -6,6 +6,8 @@ import java.util.ArrayList; import mekanism.api.Object3D; import mekanism.common.PacketHandler; import mekanism.common.PacketHandler.Transmission; +import mekanism.common.miner.MinerFilter; +import mekanism.common.tileentity.TileEntityDigitalMiner; import mekanism.common.tileentity.TileEntityLogisticalSorter; import mekanism.common.transporter.TransporterFilter; import net.minecraft.entity.player.EntityPlayer; @@ -19,9 +21,13 @@ public class PacketEditFilter implements IMekanismPacket { public Object3D object3D; - public TransporterFilter filter; + public TransporterFilter tFilter; + public TransporterFilter tEdited; - public TransporterFilter edited; + public MinerFilter mFilter; + public MinerFilter mEdited; + + public byte type = -1; public boolean delete; @@ -36,11 +42,28 @@ public class PacketEditFilter implements IMekanismPacket { object3D = (Object3D)data[0]; delete = (Boolean)data[1]; - filter = (TransporterFilter)data[2]; - if(!delete) + if(data[2] instanceof TransporterFilter) { - edited = (TransporterFilter)data[3]; + tFilter = (TransporterFilter)data[2]; + + if(!delete) + { + tEdited = (TransporterFilter)data[3]; + } + + type = 0; + } + else if(data[2] instanceof MinerFilter) + { + mFilter = (MinerFilter)data[2]; + + if(!delete) + { + mEdited = (MinerFilter)data[3]; + } + + type = 1; } return this; @@ -51,37 +74,77 @@ public class PacketEditFilter implements IMekanismPacket { object3D = new Object3D(dataStream.readInt(), dataStream.readInt(), dataStream.readInt(), dataStream.readInt()); + type = dataStream.readByte(); delete = dataStream.readBoolean(); - filter = TransporterFilter.readFromPacket(dataStream); - if(!delete) + if(type == 0) { - edited = TransporterFilter.readFromPacket(dataStream); + tFilter = TransporterFilter.readFromPacket(dataStream); + + if(!delete) + { + tEdited = TransporterFilter.readFromPacket(dataStream); + } + } + else if(type == 1) + { + mFilter = MinerFilter.readFromPacket(dataStream); + + if(!delete) + { + mEdited = MinerFilter.readFromPacket(dataStream); + } } World worldServer = FMLCommonHandler.instance().getMinecraftServerInstance().worldServerForDimension(object3D.dimensionId); - if(worldServer != null && object3D.getTileEntity(worldServer) instanceof TileEntityLogisticalSorter) + if(worldServer != null) { - TileEntityLogisticalSorter sorter = (TileEntityLogisticalSorter)object3D.getTileEntity(worldServer); - - if(!sorter.filters.contains(filter)) + if(type == 0 && object3D.getTileEntity(worldServer) instanceof TileEntityLogisticalSorter) { - return; + TileEntityLogisticalSorter sorter = (TileEntityLogisticalSorter)object3D.getTileEntity(worldServer); + + if(!sorter.filters.contains(tFilter)) + { + return; + } + + int index = sorter.filters.indexOf(tFilter); + + sorter.filters.remove(index); + + if(!delete) + { + sorter.filters.add(index, tEdited); + } + + for(EntityPlayer iterPlayer : sorter.playersUsing) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(sorter), sorter.getFilterPacket(new ArrayList())), iterPlayer); + } } - - int index = sorter.filters.indexOf(filter); - - sorter.filters.remove(index); - - if(!delete) + else if(type == 0 && object3D.getTileEntity(worldServer) instanceof TileEntityDigitalMiner) { - sorter.filters.add(index, edited); - } - - for(EntityPlayer iterPlayer : sorter.playersUsing) - { - PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(sorter), sorter.getFilterPacket(new ArrayList())), iterPlayer); + TileEntityDigitalMiner miner = (TileEntityDigitalMiner)object3D.getTileEntity(worldServer); + + if(!miner.filters.contains(mFilter)) + { + return; + } + + int index = miner.filters.indexOf(mFilter); + + miner.filters.remove(index); + + if(!delete) + { + miner.filters.add(index, mEdited); + } + + for(EntityPlayer iterPlayer : miner.playersUsing) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(miner), miner.getFilterPacket(new ArrayList())), iterPlayer); + } } } } @@ -95,14 +158,29 @@ public class PacketEditFilter implements IMekanismPacket dataStream.writeInt(object3D.dimensionId); + dataStream.writeByte(type); + dataStream.writeBoolean(delete); ArrayList data = new ArrayList(); - filter.write(data); - if(!delete) + if(type == 0) { - edited.write(data); + tFilter.write(data); + + if(!delete) + { + tEdited.write(data); + } + } + else if(type == 1) + { + mFilter.write(data); + + if(!delete) + { + mEdited.write(data); + } } PacketHandler.encode(data.toArray(), dataStream); diff --git a/common/mekanism/common/network/PacketLogisticalSorterGui.java b/common/mekanism/common/network/PacketLogisticalSorterGui.java index 599a44714..fc42c31da 100644 --- a/common/mekanism/common/network/PacketLogisticalSorterGui.java +++ b/common/mekanism/common/network/PacketLogisticalSorterGui.java @@ -3,9 +3,9 @@ package mekanism.common.network; import java.io.DataOutputStream; import mekanism.api.Object3D; -import mekanism.client.gui.GuiItemStackFilter; +import mekanism.client.gui.GuiTItemStackFilter; import mekanism.client.gui.GuiLogisticalSorter; -import mekanism.client.gui.GuiOreDictFilter; +import mekanism.client.gui.GuiTOreDictFilter; import mekanism.common.Mekanism; import mekanism.common.PacketHandler; import mekanism.common.PacketHandler.Transmission; @@ -160,22 +160,22 @@ public class PacketLogisticalSorterGui implements IMekanismPacket { if(type == 1) { - return new GuiItemStackFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z)); + return new GuiTItemStackFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z)); } else if(type == 2) { - return new GuiOreDictFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z)); + return new GuiTOreDictFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z)); } } else if(packetType == SorterGuiPacket.CLIENT_INDEX) { if(type == 1) { - return new GuiItemStackFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z), index); + return new GuiTItemStackFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z), index); } else if(type == 2) { - return new GuiOreDictFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z), index); + return new GuiTOreDictFilter(player, (TileEntityLogisticalSorter)world.getBlockTileEntity(x, y, z), index); } } } diff --git a/common/mekanism/common/network/PacketNewFilter.java b/common/mekanism/common/network/PacketNewFilter.java index 4896d8d01..c28adc76c 100644 --- a/common/mekanism/common/network/PacketNewFilter.java +++ b/common/mekanism/common/network/PacketNewFilter.java @@ -6,6 +6,8 @@ import java.util.ArrayList; import mekanism.api.Object3D; import mekanism.common.PacketHandler; import mekanism.common.PacketHandler.Transmission; +import mekanism.common.miner.MinerFilter; +import mekanism.common.tileentity.TileEntityDigitalMiner; import mekanism.common.tileentity.TileEntityLogisticalSorter; import mekanism.common.transporter.TransporterFilter; import net.minecraft.entity.player.EntityPlayer; @@ -19,7 +21,11 @@ public class PacketNewFilter implements IMekanismPacket { public Object3D object3D; - public TransporterFilter filter; + public TransporterFilter tFilter; + + public MinerFilter mFilter; + + public byte type = -1; @Override public String getName() @@ -31,7 +37,17 @@ public class PacketNewFilter implements IMekanismPacket public IMekanismPacket setParams(Object... data) { object3D = (Object3D)data[0]; - filter = (TransporterFilter)data[1]; + + if(data[1] instanceof TransporterFilter) + { + tFilter = (TransporterFilter)data[1]; + type = 0; + } + else if(data[1] instanceof MinerFilter) + { + mFilter = (MinerFilter)data[1]; + type = 1; + } return this; } @@ -40,19 +56,35 @@ public class PacketNewFilter implements IMekanismPacket public void read(ByteArrayDataInput dataStream, EntityPlayer player, World world) throws Exception { object3D = new Object3D(dataStream.readInt(), dataStream.readInt(), dataStream.readInt(), dataStream.readInt()); + type = dataStream.readByte(); World worldServer = FMLCommonHandler.instance().getMinecraftServerInstance().worldServerForDimension(object3D.dimensionId); - if(worldServer != null && object3D.getTileEntity(worldServer) instanceof TileEntityLogisticalSorter) + if(worldServer != null) { - TileEntityLogisticalSorter sorter = (TileEntityLogisticalSorter)object3D.getTileEntity(worldServer); - TransporterFilter filter = TransporterFilter.readFromPacket(dataStream); - - sorter.filters.add(filter); - - for(EntityPlayer iterPlayer : sorter.playersUsing) + if(type == 0 && object3D.getTileEntity(worldServer) instanceof TileEntityLogisticalSorter) { - PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(sorter), sorter.getFilterPacket(new ArrayList())), iterPlayer); + TileEntityLogisticalSorter sorter = (TileEntityLogisticalSorter)object3D.getTileEntity(worldServer); + TransporterFilter filter = TransporterFilter.readFromPacket(dataStream); + + sorter.filters.add(filter); + + for(EntityPlayer iterPlayer : sorter.playersUsing) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(sorter), sorter.getFilterPacket(new ArrayList())), iterPlayer); + } + } + else if(type == 1 && object3D.getTileEntity(worldServer) instanceof TileEntityDigitalMiner) + { + TileEntityDigitalMiner miner = (TileEntityDigitalMiner)object3D.getTileEntity(worldServer); + MinerFilter filter = MinerFilter.readFromPacket(dataStream); + + miner.filters.add(filter); + + for(EntityPlayer iterPlayer : miner.playersUsing) + { + PacketHandler.sendPacket(Transmission.SINGLE_CLIENT, new PacketTileEntity().setParams(Object3D.get(miner), miner.getFilterPacket(new ArrayList())), iterPlayer); + } } } } @@ -66,8 +98,19 @@ public class PacketNewFilter implements IMekanismPacket dataStream.writeInt(object3D.dimensionId); + dataStream.writeByte(type); + ArrayList data = new ArrayList(); - filter.write(data); + + if(type == 0) + { + tFilter.write(data); + } + else if(type == 1) + { + mFilter.write(data); + } + PacketHandler.encode(data.toArray(), dataStream); } } diff --git a/common/mekanism/common/tileentity/TileEntityDigitalMiner.java b/common/mekanism/common/tileentity/TileEntityDigitalMiner.java index 8c5ba978e..d0458fc62 100644 --- a/common/mekanism/common/tileentity/TileEntityDigitalMiner.java +++ b/common/mekanism/common/tileentity/TileEntityDigitalMiner.java @@ -9,6 +9,7 @@ import java.util.Set; import mekanism.api.Object3D; import mekanism.api.energy.IStrictEnergyAcceptor; import mekanism.common.HashList; +import mekanism.common.IActiveState; import mekanism.common.IRedstoneControl; import mekanism.common.IUpgradeTile; import mekanism.common.Mekanism; @@ -16,6 +17,8 @@ import mekanism.common.PacketHandler; import mekanism.common.PacketHandler.Transmission; import mekanism.common.TileComponentUpgrade; import mekanism.common.block.BlockMachine.MachineType; +import mekanism.common.inventory.container.ContainerFilter; +import mekanism.common.inventory.container.ContainerNull; import mekanism.common.miner.MinerFilter; import mekanism.common.miner.ThreadMinerSearch; import mekanism.common.network.PacketTileEntity; @@ -30,7 +33,7 @@ import net.minecraftforge.common.ForgeDirection; import com.google.common.io.ByteArrayDataInput; -public class TileEntityDigitalMiner extends TileEntityElectricBlock implements IEnergySink, IStrictEnergyAcceptor, IUpgradeTile, IRedstoneControl +public class TileEntityDigitalMiner extends TileEntityElectricBlock implements IEnergySink, IStrictEnergyAcceptor, IUpgradeTile, IRedstoneControl, IActiveState { public Set oresToMine = new HashSet(); @@ -50,6 +53,9 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I public ItemStack replaceStack; + public boolean isActive; + public boolean clientActive; + /** This machine's current RedstoneControl type. */ public RedstoneControl controlType = RedstoneControl.DISABLED; @@ -67,6 +73,17 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I { super.onUpdate(); + if(getActive()) + { + for(EntityPlayer player : playersUsing) + { + if(player.openContainer instanceof ContainerNull || player.openContainer instanceof ContainerFilter) + { + player.closeScreen(); + } + } + } + if(!worldObj.isRemote) { ChargeUtils.discharge(27, this); @@ -91,6 +108,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I maxY = nbtTags.getInteger("maxY"); doEject = nbtTags.getBoolean("doEject"); doPull = nbtTags.getBoolean("doPull"); + isActive = nbtTags.getBoolean("isActive"); controlType = RedstoneControl.values()[nbtTags.getInteger("controlType")]; if(nbtTags.hasKey("replaceStack")) @@ -129,6 +147,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I nbtTags.setInteger("maxY", maxY); nbtTags.setBoolean("doEject", doEject); nbtTags.setBoolean("doPull", doPull); + nbtTags.setBoolean("isActive", isActive); nbtTags.setInteger("controlType", controlType.ordinal()); if(replaceStack != null) @@ -176,6 +195,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I doEject = dataStream.readBoolean(); doPull = dataStream.readBoolean(); clientToMine = dataStream.readInt(); + isActive = dataStream.readBoolean(); controlType = RedstoneControl.values()[dataStream.readInt()]; filters.clear(); @@ -195,6 +215,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I doEject = dataStream.readBoolean(); doPull = dataStream.readBoolean(); clientToMine = dataStream.readInt(); + isActive = dataStream.readBoolean(); controlType = RedstoneControl.values()[dataStream.readInt()]; } else if(type == 2) @@ -221,6 +242,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I data.add(maxY); data.add(doEject); data.add(doPull); + data.add(isActive); data.add(oresToMine.size()); data.add(controlType.ordinal()); @@ -246,6 +268,7 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I data.add(maxY); data.add(doEject); data.add(doPull); + data.add(isActive); data.add(oresToMine.size()); data.add(controlType.ordinal()); @@ -395,4 +418,40 @@ public class TileEntityDigitalMiner extends TileEntityElectricBlock implements I { return true; } + + @Override + public void setActive(boolean active) + { + isActive = active; + + if(clientActive != active) + { + PacketHandler.sendPacket(Transmission.ALL_CLIENTS, new PacketTileEntity().setParams(Object3D.get(this), getNetworkedData(new ArrayList()))); + + if(active) + { + worldObj.playSoundEffect(xCoord, yCoord, zCoord, "mekanism:etc.Click", 0.3F, 1); + } + + clientActive = active; + } + } + + @Override + public boolean getActive() + { + return isActive; + } + + @Override + public boolean renderUpdate() + { + return true; + } + + @Override + public boolean lightUpdate() + { + return true; + } }