tilera/Mekanism-tilera-Edition
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Work on networking and GUIs of Digital Miner

Browse source
This commit is contained in:
Aidan C. Brady 2013-11-19 17:39:16 -05:00
parent c9deba55df
commit 87f5bbcde2
14 changed files with 1560 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
common/mekanism/client/gui/GuiDigitalMiner.java
View file

@ -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);
}
}

475
common/mekanism/client/gui/GuiDigitalMinerConfig.java
View file

@ -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<MOreDictFilter, StackData> oreDictStacks = new HashMap<MOreDictFilter, StackData>();
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<MOreDictFilter, StackData> 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<MOreDictFilter, StackData> entry : oreDictStacks.entrySet())
{
if(entry.getValue().iterStacks != null && entry.getValue().iterStacks.size() == 0)
{
entry.getValue().renderStack = null;
}
}
}
Set<MOreDictFilter> filtersVisible = new HashSet<MOreDictFilter>();
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<ItemStack>();
}
else {
oreDictStacks.get(filter).iterStacks.clear();
}
List<String> keys = new ArrayList<String>();
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<ItemStack> iterStacks;
public int stackIndex;
public ItemStack renderStack;
}
}

229
common/mekanism/client/gui/GuiMItemStackFilter.java Normal file
View file

@ -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);
}
}
}
}

349
common/mekanism/client/gui/GuiMOreDictFilter.java Normal file
View file

@ -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<ItemStack> 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<ItemStack>();
}
else {
iterStacks.clear();
}
List<String> keys = new ArrayList<String>();
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("");
}
}

6
common/mekanism/client/gui/GuiItemStackFilter.java → common/mekanism/client/gui/GuiTItemStackFilter.java
View file

@ -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;

6
common/mekanism/client/gui/GuiOreDictFilter.java → common/mekanism/client/gui/GuiTOreDictFilter.java
View file

@ -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;

2
common/mekanism/common/Mekanism.java
View file

@ -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");

1
common/mekanism/common/inventory/container/ContainerDigitalMiner.java
View file

@ -53,7 +53,6 @@ public class ContainerDigitalMiner extends Container
{
super.onContainerClosed(entityplayer);
tileEntity.closeChest();
tileEntity.playersUsing.remove(entityplayer);
}

6
common/mekanism/common/inventory/container/ContainerFilter.java
View file

@ -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)

213
common/mekanism/common/network/PacketDigitalMinerGui.java Normal file
View file

@ -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
}
}

134
common/mekanism/common/network/PacketEditFilter.java
View file

@ -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);

12
common/mekanism/common/network/PacketLogisticalSorterGui.java
View file

@ -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);
}
}
}

65
common/mekanism/common/network/PacketNewFilter.java
View file

@ -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);
}
}

61
common/mekanism/common/tileentity/TileEntityDigitalMiner.java
View file

@ -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<Object3D> oresToMine = new HashSet<Object3D>();
@ -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;
}
}