diff --git a/src/main/java/mekanism/client/ClientProxy.java b/src/main/java/mekanism/client/ClientProxy.java index 0cc0e382f..4255d1657 100644 --- a/src/main/java/mekanism/client/ClientProxy.java +++ b/src/main/java/mekanism/client/ClientProxy.java @@ -53,6 +53,7 @@ import mekanism.client.gui.GuiRobitMain; import mekanism.client.gui.GuiRobitRepair; import mekanism.client.gui.GuiRobitSmelting; import mekanism.client.gui.GuiRotaryCondensentrator; +import mekanism.client.gui.GuiSecurityDesk; import mekanism.client.gui.GuiSeismicReader; import mekanism.client.gui.GuiSeismicVibrator; import mekanism.client.gui.GuiSideConfiguration; @@ -173,6 +174,7 @@ import mekanism.common.tile.TileEntityPurificationChamber; import mekanism.common.tile.TileEntityQuantumEntangloporter; import mekanism.common.tile.TileEntityResistiveHeater; import mekanism.common.tile.TileEntityRotaryCondensentrator; +import mekanism.common.tile.TileEntitySecurityDesk; import mekanism.common.tile.TileEntitySeismicVibrator; import mekanism.common.tile.TileEntitySolarNeutronActivator; import mekanism.common.tile.TileEntityStructuralGlass; @@ -345,6 +347,7 @@ public class ClientProxy extends CommonProxy GameRegistry.registerTileEntity(TileEntityResistiveHeater.class, "ResistiveHeater"); ClientRegistry.registerTileEntity(TileEntityBoilerCasing.class, "BoilerCasing", new RenderThermoelectricBoiler()); ClientRegistry.registerTileEntity(TileEntityBoilerValve.class, "BoilerValve", new RenderThermoelectricBoiler()); + GameRegistry.registerTileEntity(TileEntitySecurityDesk.class, "SecurityDesk"); } @Override @@ -533,6 +536,8 @@ public class ClientProxy extends CommonProxy return new GuiBoilerStats(player.inventory, (TileEntityBoilerCasing)tileEntity); case 56: return new GuiFormulaicAssemblicator(player.inventory, (TileEntityFormulaicAssemblicator)tileEntity); + case 57: + return new GuiSecurityDesk(player.inventory, (TileEntitySecurityDesk)tileEntity); } return null; diff --git a/src/main/java/mekanism/client/gui/GuiQuantumEntangloporter.java b/src/main/java/mekanism/client/gui/GuiQuantumEntangloporter.java index e6a1a9d47..ced64de7b 100644 --- a/src/main/java/mekanism/client/gui/GuiQuantumEntangloporter.java +++ b/src/main/java/mekanism/client/gui/GuiQuantumEntangloporter.java @@ -48,8 +48,6 @@ public class GuiQuantumEntangloporter extends GuiMekanism public GuiButton setButton; public GuiButton deleteButton; - public GuiButton teleportButton; - public GuiScrollList scrollList; public GuiTextField frequencyField; diff --git a/src/main/java/mekanism/client/gui/GuiSecurityDesk.java b/src/main/java/mekanism/client/gui/GuiSecurityDesk.java new file mode 100644 index 000000000..268bdd64c --- /dev/null +++ b/src/main/java/mekanism/client/gui/GuiSecurityDesk.java @@ -0,0 +1,375 @@ +package mekanism.client.gui; + +import java.util.ArrayList; +import java.util.List; + +import mekanism.api.Coord4D; +import mekanism.api.EnumColor; +import mekanism.client.gui.element.GuiScrollList; +import mekanism.client.sound.SoundHandler; +import mekanism.common.Mekanism; +import mekanism.common.inventory.container.ContainerSecurityDesk; +import mekanism.common.network.PacketTileEntity.TileEntityMessage; +import mekanism.common.security.ISecurity.SecurityMode; +import mekanism.common.tile.TileEntitySecurityDesk; +import mekanism.common.util.LangUtils; +import mekanism.common.util.MekanismUtils; +import mekanism.common.util.MekanismUtils.ResourceType; +import mekanism.common.util.SecurityUtils; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiTextField; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +@SideOnly(Side.CLIENT) +public class GuiSecurityDesk extends GuiMekanism +{ +public static int MAX_LENGTH = 24; + + public ResourceLocation resource; + + public TileEntitySecurityDesk tileEntity; + + public EntityPlayer entityPlayer; + + public GuiButton removeButton; + + public GuiScrollList scrollList; + + public GuiTextField trustedField; + + public GuiSecurityDesk(InventoryPlayer inventory, TileEntitySecurityDesk tentity) + { + super(tentity, new ContainerSecurityDesk(inventory, tentity)); + tileEntity = tentity; + resource = MekanismUtils.getResource(ResourceType.GUI, "GuiSecurityDesk.png"); + + guiElements.add(scrollList = new GuiScrollList(this, resource, 14, 14, 120, 4)); + + ySize+=64; + } + + @Override + public void initGui() + { + super.initGui(); + + int guiWidth = (width - xSize) / 2; + int guiHeight = (height - ySize) / 2; + + buttonList.clear(); + + removeButton = new GuiButton(0, guiWidth + 13, guiHeight + 116, 122, 20, LangUtils.localize("gui.remove")); + + trustedField = new GuiTextField(fontRendererObj, guiWidth + 35, guiHeight + 68, 86, 11); + trustedField.setMaxStringLength(MAX_LENGTH); + trustedField.setEnableBackgroundDrawing(false); + + updateButtons(); + + buttonList.add(removeButton); + } + + public void addTrusted(String trusted) + { + if(trusted.isEmpty()) + { + return; + } + + ArrayList data = new ArrayList(); + data.add(0); + data.add(trusted); + + Mekanism.packetHandler.sendToServer(new TileEntityMessage(Coord4D.get(tileEntity), data)); + } + + public void updateButtons() + { + if(tileEntity.owner == null) + { + return; + } + + List text = new ArrayList(); + + if(tileEntity.frequency != null) + { + for(String s : tileEntity.frequency.trusted) + { + text.add(s); + } + } + + scrollList.setText(text); + + if(scrollList.hasSelection()) + { + removeButton.enabled = true; + } + else { + removeButton.enabled = false; + } + } + + @Override + public void updateScreen() + { + super.updateScreen(); + + updateButtons(); + + trustedField.updateCursorCounter(); + } + + @Override + public void mouseClicked(int mouseX, int mouseY, int button) + { + super.mouseClicked(mouseX, mouseY, button); + + updateButtons(); + + trustedField.mouseClicked(mouseX, mouseY, button); + + if(button == 0) + { + int xAxis = (mouseX - (width - xSize) / 2); + int yAxis = (mouseY - (height - ySize) / 2); + + if(tileEntity.frequency != null && tileEntity.owner != null && tileEntity.owner.equals(mc.thePlayer.getCommandSenderName())) + { + if(xAxis >= 123 && xAxis <= 134 && yAxis >= 68 && yAxis <= 79) + { + addTrusted(trustedField.getText()); + trustedField.setText(""); + SoundHandler.playSound("gui.button.press"); + } + + ArrayList data = new ArrayList(); + + if(xAxis >= 146 && xAxis <= 162 && yAxis >= 59 && yAxis <= 75) + { + data.add(2); + } + + if(tileEntity.frequency.securityMode != SecurityMode.PUBLIC) + { + if(xAxis >= 13 && xAxis <= 53 && yAxis >= 113 && yAxis <= 129) + { + data.add(3); + data.add(0); + } + } + + if(tileEntity.frequency.securityMode != SecurityMode.PRIVATE) + { + if(xAxis >= 54 && xAxis <= 94 && yAxis >= 113 && yAxis <= 129) + { + data.add(3); + data.add(1); + } + } + + if(tileEntity.frequency.securityMode != SecurityMode.TRUSTED) + { + if(xAxis >= 95 && xAxis <= 135 && yAxis >= 113 && yAxis <= 129) + { + data.add(3); + data.add(2); + } + } + + if(!data.isEmpty()) + { + Mekanism.packetHandler.sendToServer(new TileEntityMessage(Coord4D.get(tileEntity), data)); + } + } + } + } + + @Override + public void keyTyped(char c, int i) + { + if(!trustedField.isFocused() || i == Keyboard.KEY_ESCAPE) + { + super.keyTyped(c, i); + } + + if(i == Keyboard.KEY_RETURN) + { + if(trustedField.isFocused()) + { + addTrusted(trustedField.getText()); + trustedField.setText(""); + } + } + + if(Character.isDigit(c) || Character.isLetter(c) || i == Keyboard.KEY_BACK || i == Keyboard.KEY_DELETE || i == Keyboard.KEY_LEFT || i == Keyboard.KEY_RIGHT) + { + trustedField.textboxKeyTyped(c, i); + } + + updateButtons(); + } + + @Override + protected void actionPerformed(GuiButton guibutton) + { + super.actionPerformed(guibutton); + + if(guibutton.id == 0) + { + int selection = scrollList.getSelection(); + + if(tileEntity.frequency != null && selection != -1) + { + if(tileEntity != null) + { + ArrayList data = new ArrayList(); + data.add(1); + data.add(tileEntity.frequency.trusted.get(selection)); + + Mekanism.packetHandler.sendToServer(new TileEntityMessage(Coord4D.get(tileEntity), data)); + } + + scrollList.selected = -1; + } + } + + updateButtons(); + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) + { + int xAxis = (mouseX-(width-xSize)/2); + int yAxis = (mouseY-(height-ySize)/2); + + String ownerText = SecurityUtils.getOwnerDisplay(mc.thePlayer.getCommandSenderName(), tileEntity.owner); + fontRendererObj.drawString(tileEntity.getInventoryName(), (xSize/2)-(fontRendererObj.getStringWidth(tileEntity.getInventoryName())/2), 4, 0x404040); + fontRendererObj.drawString(ownerText, (xSize - 7) - fontRendererObj.getStringWidth(ownerText), (ySize - 96) + 2, 0x404040); + fontRendererObj.drawString(LangUtils.localize("container.inventory"), 8, (ySize - 96) + 2, 0x404040); + fontRendererObj.drawString(LangUtils.localize("gui.trustedPlayers"), 13, 57, 0x404040); + + String security = EnumColor.GREY + LangUtils.localize("gui.security") + ": " + tileEntity.frequency.securityMode.getDisplay(); + fontRendererObj.drawString(security, 13, 103, 0x404040); + + renderScaledText(LangUtils.localize("gui.add") + ":", 13, 67, 0x404040, 20); + + if(tileEntity.frequency != null && xAxis >= 146 && xAxis <= 162 && yAxis >= 59 && yAxis <= 75) + { + displayTooltip(LangUtils.localize("gui.securityOverride") + ": " + LangUtils.transOnOff(tileEntity.frequency.override), xAxis, yAxis); + } + + if(xAxis >= 13 && xAxis <= 53 && yAxis >= 113 && yAxis <= 129) + { + displayTooltip(LangUtils.localize("gui.publicMode"), xAxis, yAxis); + } + + if(xAxis >= 54 && xAxis <= 94 && yAxis >= 113 && yAxis <= 129) + { + displayTooltip(LangUtils.localize("gui.privateMode"), xAxis, yAxis); + } + + if(xAxis >= 95 && xAxis <= 135 && yAxis >= 113 && yAxis <= 129) + { + displayTooltip(LangUtils.localize("gui.trustedMode"), xAxis, yAxis); + } + + super.drawGuiContainerForegroundLayer(mouseX, mouseY); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float partialTick, int mouseX, int mouseY) + { + mc.renderEngine.bindTexture(resource); + 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(tileEntity.frequency != null && tileEntity.owner != null && mc.thePlayer.getCommandSenderName().equals(tileEntity.owner)) + { + drawTexturedModalRect(guiWidth + 145, guiHeight + 78, xSize + (tileEntity.frequency.override ? 0 : 6), 22, 6, 6); + + if(xAxis >= 146 && xAxis <= 162 && yAxis >= 59 && yAxis <= 75) + { + drawTexturedModalRect(guiWidth + 146, guiHeight + 59, xSize + 12, 0, 16, 16); + } + else { + drawTexturedModalRect(guiWidth + 146, guiHeight + 59, xSize + 12, 16, 16, 16); + } + + if(tileEntity.frequency.securityMode != SecurityMode.PUBLIC) + { + if(xAxis >= 13 && xAxis <= 53 && yAxis >= 113 && yAxis <= 129) + { + drawTexturedModalRect(guiWidth + 13, guiHeight + 113, xSize, 48, 40, 16); + } + else { + drawTexturedModalRect(guiWidth + 13, guiHeight + 113, xSize, 64, 40, 16); + } + } + else { + drawTexturedModalRect(guiWidth + 13, guiHeight + 113, xSize, 80, 40, 16); + } + + if(tileEntity.frequency.securityMode != SecurityMode.PRIVATE) + { + if(xAxis >= 54 && xAxis <= 94 && yAxis >= 113 && yAxis <= 129) + { + drawTexturedModalRect(guiWidth + 54, guiHeight + 113, xSize + 40, 48, 40, 16); + } + else { + drawTexturedModalRect(guiWidth + 54, guiHeight + 113, xSize + 40, 64, 40, 16); + } + } + else { + drawTexturedModalRect(guiWidth + 54, guiHeight + 113, xSize + 40, 80, 40, 16); + } + + if(tileEntity.frequency.securityMode != SecurityMode.TRUSTED) + { + if(xAxis >= 95 && xAxis <= 135 && yAxis >= 113 && yAxis <= 129) + { + drawTexturedModalRect(guiWidth + 95, guiHeight + 113, xSize, 96, 40, 16); + } + else { + drawTexturedModalRect(guiWidth + 95, guiHeight + 113, xSize, 112, 40, 16); + } + } + else { + drawTexturedModalRect(guiWidth + 95, guiHeight + 113, xSize, 128, 40, 16); + } + } + else { + drawTexturedModalRect(guiWidth + 145, guiHeight + 78, xSize, 28, 6, 6); + drawTexturedModalRect(guiWidth + 146, guiHeight + 59, xSize + 12, 32, 16, 16); + drawTexturedModalRect(guiWidth + 13, guiHeight + 113, xSize, 80, 40, 16); + drawTexturedModalRect(guiWidth + 54, guiHeight + 113, xSize + 40, 80, 40, 16); + drawTexturedModalRect(guiWidth + 95, guiHeight + 113, xSize, 128, 40, 16); + } + + if(xAxis >= 123 && xAxis <= 134 && yAxis >= 68 && yAxis <= 79) + { + drawTexturedModalRect(guiWidth + 123, guiHeight + 68, xSize, 0, 11, 11); + } + else { + drawTexturedModalRect(guiWidth + 123, guiHeight + 68, xSize, 11, 11, 11); + } + + super.drawGuiContainerBackgroundLayer(partialTick, mouseX, mouseY); + + trustedField.drawTextBox(); + } +} diff --git a/src/main/java/mekanism/client/gui/element/GuiSecurityTab.java b/src/main/java/mekanism/client/gui/element/GuiSecurityTab.java index bb7893610..2bc0aaab9 100644 --- a/src/main/java/mekanism/client/gui/element/GuiSecurityTab.java +++ b/src/main/java/mekanism/client/gui/element/GuiSecurityTab.java @@ -12,6 +12,7 @@ import mekanism.common.security.ISecurity.SecurityMode; import mekanism.common.util.LangUtils; import mekanism.common.util.MekanismUtils; import mekanism.common.util.MekanismUtils.ResourceType; +import mekanism.common.util.SecurityUtils; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.ResourceLocation; import codechicken.lib.vec.Rectangle4i; @@ -73,7 +74,7 @@ public class GuiSecurityTab extends GuiElement if(xAxis >= 179 && xAxis <= 197 && yAxis >= 36 && yAxis <= 54) { String securityText = EnumColor.GREY + LangUtils.localize("gui.security") + ": " + control.getSecurity().getMode().getDisplay(); - String ownerText = ISecurity.getOwnerDisplay(mc.thePlayer.getCommandSenderName(), control.getSecurity().getOwner()); + String ownerText = SecurityUtils.getOwnerDisplay(mc.thePlayer.getCommandSenderName(), control.getSecurity().getOwner()); displayTooltips(ListUtils.asList(securityText, ownerText), xAxis, yAxis); } diff --git a/src/main/java/mekanism/common/CommonProxy.java b/src/main/java/mekanism/common/CommonProxy.java index 1715ab418..8565297f7 100644 --- a/src/main/java/mekanism/common/CommonProxy.java +++ b/src/main/java/mekanism/common/CommonProxy.java @@ -51,6 +51,7 @@ import mekanism.common.inventory.container.ContainerRobitMain; import mekanism.common.inventory.container.ContainerRobitRepair; import mekanism.common.inventory.container.ContainerRobitSmelting; import mekanism.common.inventory.container.ContainerRotaryCondensentrator; +import mekanism.common.inventory.container.ContainerSecurityDesk; import mekanism.common.inventory.container.ContainerSeismicVibrator; import mekanism.common.inventory.container.ContainerSolarNeutronActivator; import mekanism.common.inventory.container.ContainerTeleporter; @@ -110,6 +111,7 @@ import mekanism.common.tile.TileEntityPurificationChamber; import mekanism.common.tile.TileEntityQuantumEntangloporter; import mekanism.common.tile.TileEntityResistiveHeater; import mekanism.common.tile.TileEntityRotaryCondensentrator; +import mekanism.common.tile.TileEntitySecurityDesk; import mekanism.common.tile.TileEntitySeismicVibrator; import mekanism.common.tile.TileEntitySolarNeutronActivator; import mekanism.common.tile.TileEntityStructuralGlass; @@ -204,6 +206,7 @@ public class CommonProxy implements IGuiProvider GameRegistry.registerTileEntity(TileEntityResistiveHeater.class, "ResistiveHeater"); GameRegistry.registerTileEntity(TileEntityBoilerCasing.class, "BoilerCasing"); GameRegistry.registerTileEntity(TileEntityBoilerValve.class, "BoilerValve"); + GameRegistry.registerTileEntity(TileEntitySecurityDesk.class, "SecurityDesk"); } public void handleTeleporterUpdate(PortableTeleporterMessage message) {} @@ -554,6 +557,8 @@ public class CommonProxy implements IGuiProvider return new ContainerNull(player, (TileEntityContainerBlock)tileEntity); case 56: return new ContainerFormulaicAssemblicator(player.inventory, (TileEntityFormulaicAssemblicator)tileEntity); + case 57: + return new ContainerSecurityDesk(player.inventory, (TileEntitySecurityDesk)tileEntity); } return null; diff --git a/src/main/java/mekanism/common/block/BlockBasic.java b/src/main/java/mekanism/common/block/BlockBasic.java index eec036bd8..071db7534 100644 --- a/src/main/java/mekanism/common/block/BlockBasic.java +++ b/src/main/java/mekanism/common/block/BlockBasic.java @@ -34,6 +34,7 @@ import mekanism.common.tile.TileEntityInductionCell; import mekanism.common.tile.TileEntityInductionPort; import mekanism.common.tile.TileEntityInductionProvider; import mekanism.common.tile.TileEntityPressureDisperser; +import mekanism.common.tile.TileEntitySecurityDesk; import mekanism.common.tile.TileEntityStructuralGlass; import mekanism.common.tile.TileEntitySuperheatingElement; import mekanism.common.tile.TileEntityThermalEvaporationBlock; @@ -94,6 +95,7 @@ import cpw.mods.fml.relauncher.SideOnly; * 1:6: Pressure Disperser * 1:7: Boiler Casing * 1:8: Boiler Valve + * 1:9: Security Desk * @author AidanBrady * */ @@ -240,6 +242,8 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon icons[7][0] = ctms[7][0].mainTextureData.icon; icons[8][0] = ctms[8][0].mainTextureData.icon; + icons[9][0] = register.registerIcon(ICON_BASE); + break; } } @@ -477,6 +481,14 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon return true; } } + else if(tile instanceof TileEntitySecurityDesk) + { + if(!entityplayer.isSneaking()) + { + entityplayer.openGui(Mekanism.instance, 57, world, x, y, z); + return true; + } + } else if(tile instanceof TileEntityBin) { TileEntityBin bin = (TileEntityBin)world.getTileEntity(x, y, z); @@ -795,6 +807,11 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon tileEntity.setFacing((short)change); tileEntity.redstone = world.isBlockIndirectlyGettingPowered(x, y, z); + + if(tileEntity instanceof TileEntitySecurityDesk) + { + ((TileEntitySecurityDesk)tileEntity).owner = entityliving.getCommandSenderName(); + } if(tileEntity instanceof IBoundingBlock) { @@ -1021,13 +1038,13 @@ public class BlockBasic extends Block implements IBlockCTM, ICustomBlockIcon SUPERHEATING_ELEMENT(BasicBlock.BASIC_BLOCK_2, 5, "SuperheatingElement", TileEntitySuperheatingElement.class, true), PRESSURE_DISPERSER(BasicBlock.BASIC_BLOCK_2, 6, "PressureDisperser", TileEntityPressureDisperser.class, true), BOILER_CASING(BasicBlock.BASIC_BLOCK_2, 7, "BoilerCasing", TileEntityBoilerCasing.class, true), - BOILER_VALVE(BasicBlock.BASIC_BLOCK_2, 8, "BoilerValve", TileEntityBoilerValve.class, true); + BOILER_VALVE(BasicBlock.BASIC_BLOCK_2, 8, "BoilerValve", TileEntityBoilerValve.class, true), + SECURITY_DESK(BasicBlock.BASIC_BLOCK_2, 9, "SecurityDesk", TileEntitySecurityDesk.class, true); public BasicBlock typeBlock; public int meta; public String name; public Class tileEntityClass; - public boolean isElectric; public boolean hasDescription; private BasicType(BasicBlock block, int i, String s, Class tileClass, boolean hasDesc) diff --git a/src/main/java/mekanism/common/inventory/container/ContainerSecurityDesk.java b/src/main/java/mekanism/common/inventory/container/ContainerSecurityDesk.java new file mode 100644 index 000000000..289a34f6c --- /dev/null +++ b/src/main/java/mekanism/common/inventory/container/ContainerSecurityDesk.java @@ -0,0 +1,124 @@ +package mekanism.common.inventory.container; + +import mekanism.common.security.ISecurityItem; +import mekanism.common.tile.TileEntitySecurityDesk; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerSecurityDesk extends Container +{ + private TileEntitySecurityDesk tileEntity; + + public ContainerSecurityDesk(InventoryPlayer inventory, TileEntitySecurityDesk tentity) + { + tileEntity = tentity; + + addSlotToContainer(new Slot(tentity, 0, 146, 18)); + addSlotToContainer(new Slot(tentity, 1, 146, 97)); + + int slotY; + + for(slotY = 0; slotY < 3; slotY++) + { + for(int slotX = 0; slotX < 9; slotX++) + { + addSlotToContainer(new Slot(inventory, slotX + slotY * 9 + 9, 8 + slotX * 18, 148 + slotY * 18)); + } + } + + for(slotY = 0; slotY < 9; slotY++) + { + addSlotToContainer(new Slot(inventory, slotY, 8 + slotY * 18, 206)); + } + + tileEntity.open(inventory.player); + tileEntity.openInventory(); + } + + @Override + public void onContainerClosed(EntityPlayer entityplayer) + { + super.onContainerClosed(entityplayer); + + tileEntity.close(entityplayer); + tileEntity.closeInventory(); + } + + @Override + public boolean canInteractWith(EntityPlayer entityplayer) + { + return tileEntity.isUseableByPlayer(entityplayer); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer player, int slotID) + { + ItemStack stack = null; + Slot currentSlot = (Slot)inventorySlots.get(slotID); + + if(currentSlot != null && currentSlot.getHasStack()) + { + ItemStack slotStack = currentSlot.getStack(); + stack = slotStack.copy(); + + if(slotStack.getItem() instanceof ISecurityItem && ((ISecurityItem)slotStack.getItem()).hasSecurity(slotStack)) + { + if(slotID != 0 && slotID != 1) + { + if(!mergeItemStack(slotStack, 1, 2, false)) + { + return null; + } + } + else { + if(!mergeItemStack(slotStack, 29, inventorySlots.size(), false)) + { + return null; + } + } + } + else { + if(slotID >= 2 && slotID <= 28) + { + if(!mergeItemStack(slotStack, 29, inventorySlots.size(), false)) + { + return null; + } + } + else if(slotID > 28) + { + if(!mergeItemStack(slotStack, 2, 28, false)) + { + return null; + } + } + else { + if(!mergeItemStack(slotStack, 2, inventorySlots.size(), true)) + { + return null; + } + } + } + + if(slotStack.stackSize == 0) + { + currentSlot.putStack((ItemStack)null); + } + else { + currentSlot.onSlotChanged(); + } + + if(slotStack.stackSize == stack.stackSize) + { + return null; + } + + currentSlot.onPickupFromSlot(player, slotStack); + } + + return stack; + } +} diff --git a/src/main/java/mekanism/common/item/ItemBlockBasic.java b/src/main/java/mekanism/common/item/ItemBlockBasic.java index 103ed3e1e..472840265 100644 --- a/src/main/java/mekanism/common/item/ItemBlockBasic.java +++ b/src/main/java/mekanism/common/item/ItemBlockBasic.java @@ -65,6 +65,7 @@ import cpw.mods.fml.relauncher.SideOnly; * 1:6: Pressure Disperser * 1:7: Boiler Casing * 1:8: Boiler Valve + * 1:9: Security Desk * @author AidanBrady * */ diff --git a/src/main/java/mekanism/common/security/ISecurity.java b/src/main/java/mekanism/common/security/ISecurity.java index 1704a6557..16fa0727f 100644 --- a/src/main/java/mekanism/common/security/ISecurity.java +++ b/src/main/java/mekanism/common/security/ISecurity.java @@ -1,13 +1,8 @@ package mekanism.common.security; import mekanism.api.EnumColor; -import mekanism.common.Mekanism; -import mekanism.common.frequency.Frequency; import mekanism.common.tile.component.TileComponentSecurity; import mekanism.common.util.LangUtils; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; public interface ISecurity { @@ -32,75 +27,4 @@ public interface ISecurity display = s; } } - - public static boolean canAccess(EntityPlayer player, ItemStack stack) - { - if(stack == null || !(stack.getItem() instanceof ISecurityItem)) - { - return true; - } - - ISecurityItem security = (ISecurityItem)stack.getItem(); - - return canAccess(security.getSecurity(stack), player.getCommandSenderName(), security.getOwner(stack)); - } - - public static boolean canAccess(EntityPlayer player, TileEntity tile) - { - if(tile == null || !(tile instanceof ISecurity)) - { - return true; - } - - ISecurity security = (ISecurity)tile; - - return canAccess(security.getSecurity().getMode(), player.getCommandSenderName(), security.getSecurity().getOwner()); - } - - public static boolean canAccess(SecurityMode mode, String username, String owner) - { - if(owner == null || username.equals(owner)) - { - return true; - } - - if(mode == SecurityMode.PUBLIC) - { - return true; - } - else if(mode == SecurityMode.TRUSTED) - { - SecurityFrequency freq = getFrequency(owner); - - if(freq == null || freq.trusted.contains(username)) - { - return true; - } - } - - return false; - } - - public static SecurityFrequency getFrequency(String owner) - { - for(Frequency f : Mekanism.securityFrequencies.getFrequencies()) - { - if(f instanceof SecurityFrequency && f.owner.equals(owner)) - { - return (SecurityFrequency)f; - } - } - - return null; - } - - public static String getOwnerDisplay(String user, String owner) - { - if(owner == null) - { - return EnumColor.RED + LangUtils.localize("gui.noOwner"); - } - - return EnumColor.GREY + LangUtils.localize("gui.owner") + ": " + (user.equals(owner) ? EnumColor.BRIGHT_GREEN : EnumColor.RED) + owner; - } } diff --git a/src/main/java/mekanism/common/security/ISecurityItem.java b/src/main/java/mekanism/common/security/ISecurityItem.java index 413cf2e6a..6fa80955a 100644 --- a/src/main/java/mekanism/common/security/ISecurityItem.java +++ b/src/main/java/mekanism/common/security/ISecurityItem.java @@ -12,4 +12,6 @@ public interface ISecurityItem public SecurityMode getSecurity(ItemStack stack); public void setSecurity(ItemStack stack, SecurityMode mode); + + public boolean hasSecurity(ItemStack stack); } diff --git a/src/main/java/mekanism/common/security/SecurityFrequency.java b/src/main/java/mekanism/common/security/SecurityFrequency.java index d028ade24..b7cf395ee 100644 --- a/src/main/java/mekanism/common/security/SecurityFrequency.java +++ b/src/main/java/mekanism/common/security/SecurityFrequency.java @@ -17,13 +17,16 @@ public class SecurityFrequency extends Frequency { public boolean override; - public HashList trusted = new HashList(); + public HashList trusted; - public SecurityMode securityMode = SecurityMode.PUBLIC; + public SecurityMode securityMode; public SecurityFrequency(String o) { super("Security", o); + + trusted = new HashList(); + securityMode = SecurityMode.PUBLIC; } public SecurityFrequency(NBTTagCompound nbtTags) @@ -62,6 +65,9 @@ public class SecurityFrequency extends Frequency { super.read(nbtTags); + trusted = new HashList(); + securityMode = SecurityMode.PUBLIC; + override = nbtTags.getBoolean("override"); securityMode = SecurityMode.values()[nbtTags.getInteger("securityMode")]; @@ -88,7 +94,7 @@ public class SecurityFrequency extends Frequency for(String s : trusted) { - data.add(trusted); + data.add(s); } } @@ -97,6 +103,9 @@ public class SecurityFrequency extends Frequency { super.read(dataStream); + trusted = new HashList(); + securityMode = SecurityMode.PUBLIC; + override = dataStream.readBoolean(); securityMode = SecurityMode.values()[dataStream.readInt()]; diff --git a/src/main/java/mekanism/common/tile/TileEntitySecurityDesk.java b/src/main/java/mekanism/common/tile/TileEntitySecurityDesk.java new file mode 100644 index 000000000..c6b7a83cb --- /dev/null +++ b/src/main/java/mekanism/common/tile/TileEntitySecurityDesk.java @@ -0,0 +1,259 @@ +package mekanism.common.tile; + +import io.netty.buffer.ByteBuf; + +import java.util.ArrayList; + +import mekanism.api.Coord4D; +import mekanism.common.Mekanism; +import mekanism.common.PacketHandler; +import mekanism.common.frequency.Frequency; +import mekanism.common.frequency.FrequencyManager; +import mekanism.common.security.ISecurity.SecurityMode; +import mekanism.common.security.ISecurityItem; +import mekanism.common.security.SecurityFrequency; +import mekanism.common.util.MekanismUtils; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class TileEntitySecurityDesk extends TileEntityContainerBlock +{ + public String owner; + + public SecurityFrequency frequency; + + public TileEntitySecurityDesk() + { + super("SecurityDesk"); + + inventory = new ItemStack[2]; + } + + @Override + public void onUpdate() + { + if(!worldObj.isRemote) + { + if(owner != null && frequency != null) + { + if(inventory[0] != null && inventory[0].getItem() instanceof ISecurityItem) + { + ISecurityItem item = (ISecurityItem)inventory[0].getItem(); + + if(item.hasSecurity(inventory[0])) + { + item.setOwner(inventory[0], null); + item.setSecurity(inventory[0], SecurityMode.PUBLIC); + } + } + + if(inventory[1] != null && inventory[1].getItem() instanceof ISecurityItem) + { + ISecurityItem item = (ISecurityItem)inventory[1].getItem(); + + if(item.hasSecurity(inventory[1])) + { + item.setOwner(inventory[1], owner); + item.setSecurity(inventory[1], frequency.securityMode); + } + } + } + + if(frequency == null && owner != null) + { + setFrequency(owner); + } + + FrequencyManager manager = getManager(frequency); + + if(manager != null) + { + if(frequency != null && !frequency.valid) + { + frequency = (SecurityFrequency)manager.validateFrequency(owner, Coord4D.get(this), frequency); + } + + if(frequency != null) + { + frequency = (SecurityFrequency)manager.update(owner, Coord4D.get(this), frequency); + } + } + else { + frequency = null; + } + } + } + + public FrequencyManager getManager(Frequency freq) + { + if(owner == null || freq == null) + { + return null; + } + + return Mekanism.securityFrequencies; + } + + public void setFrequency(String owner) + { + FrequencyManager manager = Mekanism.securityFrequencies; + manager.deactivate(Coord4D.get(this)); + + for(Frequency freq : manager.getFrequencies()) + { + if(freq.owner.equals(owner)) + { + frequency = (SecurityFrequency)freq; + frequency.activeCoords.add(Coord4D.get(this)); + + return; + } + } + + Frequency freq = new SecurityFrequency(owner).setPublic(true); + freq.activeCoords.add(Coord4D.get(this)); + manager.addFrequency(freq); + frequency = (SecurityFrequency)freq; + + MekanismUtils.saveChunk(this); + markDirty(); + } + + @Override + public void handlePacketData(ByteBuf dataStream) + { + if(!worldObj.isRemote) + { + int type = dataStream.readInt(); + + if(type == 0) + { + if(frequency != null) + { + frequency.trusted.add(PacketHandler.readString(dataStream)); + } + } + else if(type == 1) + { + if(frequency != null) + { + frequency.trusted.remove(PacketHandler.readString(dataStream)); + } + } + else if(type == 2) + { + if(frequency != null) + { + frequency.override = !frequency.override; + } + } + else if(type == 3) + { + if(frequency != null) + { + frequency.securityMode = SecurityMode.values()[dataStream.readInt()]; + } + } + + MekanismUtils.saveChunk(this); + + return; + } + + super.handlePacketData(dataStream); + + if(dataStream.readBoolean()) + { + owner = PacketHandler.readString(dataStream); + } + else { + owner = null; + } + + if(dataStream.readBoolean()) + { + frequency = new SecurityFrequency(dataStream); + } + else { + frequency = null; + } + } + + @Override + public void readFromNBT(NBTTagCompound nbtTags) + { + super.readFromNBT(nbtTags); + + if(nbtTags.hasKey("owner")) + { + owner = nbtTags.getString("owner"); + } + + if(nbtTags.hasKey("frequency")) + { + frequency = new SecurityFrequency(nbtTags.getCompoundTag("frequency")); + frequency.valid = false; + } + } + + @Override + public void writeToNBT(NBTTagCompound nbtTags) + { + super.writeToNBT(nbtTags); + + if(owner != null) + { + nbtTags.setString("owner", owner); + } + + if(frequency != null) + { + NBTTagCompound frequencyTag = new NBTTagCompound(); + frequency.write(frequencyTag); + nbtTags.setTag("frequency", frequencyTag); + } + } + + @Override + public ArrayList getNetworkedData(ArrayList data) + { + super.getNetworkedData(data); + + if(owner != null) + { + data.add(true); + data.add(owner); + } + else { + data.add(false); + } + + if(frequency != null) + { + data.add(true); + frequency.write(data); + } + else { + data.add(false); + } + + return data; + } + + @Override + public void invalidate() + { + if(!worldObj.isRemote) + { + if(frequency != null) + { + FrequencyManager manager = getManager(frequency); + + if(manager != null) + { + manager.deactivate(Coord4D.get(this)); + } + } + } + } +} diff --git a/src/main/java/mekanism/common/util/SecurityUtils.java b/src/main/java/mekanism/common/util/SecurityUtils.java new file mode 100644 index 000000000..2ae6d131c --- /dev/null +++ b/src/main/java/mekanism/common/util/SecurityUtils.java @@ -0,0 +1,96 @@ +package mekanism.common.util; + +import mekanism.api.EnumColor; +import mekanism.common.Mekanism; +import mekanism.common.frequency.Frequency; +import mekanism.common.security.ISecurity; +import mekanism.common.security.ISecurity.SecurityMode; +import mekanism.common.security.ISecurityItem; +import mekanism.common.security.SecurityFrequency; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; + +public final class SecurityUtils +{ + public static boolean canAccess(EntityPlayer player, ItemStack stack) + { + if(stack == null || !(stack.getItem() instanceof ISecurityItem)) + { + return true; + } + + ISecurityItem security = (ISecurityItem)stack.getItem(); + + return canAccess(security.getSecurity(stack), player.getCommandSenderName(), security.getOwner(stack)); + } + + public static boolean canAccess(EntityPlayer player, TileEntity tile) + { + if(tile == null || !(tile instanceof ISecurity)) + { + return true; + } + + ISecurity security = (ISecurity)tile; + + return canAccess(security.getSecurity().getMode(), player.getCommandSenderName(), security.getSecurity().getOwner()); + } + + public static boolean canAccess(SecurityMode mode, String username, String owner) + { + if(owner == null || username.equals(owner)) + { + return true; + } + + SecurityFrequency freq = getFrequency(owner); + + if(freq == null) + { + return true; + } + + if(freq.override) + { + mode = freq.securityMode; + } + + if(mode == SecurityMode.PUBLIC) + { + return true; + } + else if(mode == SecurityMode.TRUSTED) + { + if(freq.trusted.contains(username)) + { + return true; + } + } + + return false; + } + + public static SecurityFrequency getFrequency(String owner) + { + for(Frequency f : Mekanism.securityFrequencies.getFrequencies()) + { + if(f instanceof SecurityFrequency && f.owner.equals(owner)) + { + return (SecurityFrequency)f; + } + } + + return null; + } + + public static String getOwnerDisplay(String user, String owner) + { + if(owner == null) + { + return EnumColor.RED + LangUtils.localize("gui.noOwner"); + } + + return EnumColor.GREY + LangUtils.localize("gui.owner") + ": " + (user.equals(owner) ? EnumColor.BRIGHT_GREEN : EnumColor.RED) + owner; + } +} diff --git a/src/main/resources/assets/mekanism/gui/GuiSecurityDesk.png b/src/main/resources/assets/mekanism/gui/GuiSecurityDesk.png index 72dd35c61..1c20e25ba 100644 Binary files a/src/main/resources/assets/mekanism/gui/GuiSecurityDesk.png and b/src/main/resources/assets/mekanism/gui/GuiSecurityDesk.png differ diff --git a/src/main/resources/assets/mekanism/lang/en_US.lang b/src/main/resources/assets/mekanism/lang/en_US.lang index d0c50a4bf..383b3821e 100644 --- a/src/main/resources/assets/mekanism/lang/en_US.lang +++ b/src/main/resources/assets/mekanism/lang/en_US.lang @@ -114,6 +114,7 @@ tile.BasicBlock2.SuperheatingElement.name=Superheating Element tile.BasicBlock2.PressureDisperser.name=Pressure Disperser tile.BasicBlock2.BoilerCasing.name=Boiler Casing tile.BasicBlock2.BoilerValve.name=Boiler Valve +tile.BasicBlock2.SecurityDesk.name=Security Desk //Machine Block tile.MachineBlock.EnrichmentChamber.name=Enrichment Chamber @@ -541,6 +542,12 @@ gui.craftSingle=Craft Single Item gui.craftAvailable=Craft Available Items gui.fillEmpty=Fill/Empty Grid gui.noOwner=No Owner +gui.securityOverride=Security Override +gui.remove=Remove +gui.trustedPlayers=Trusted Players +gui.publicMode=Public Mode (universal access) +gui.privateMode=Private Mode (owner-exclusive access) +gui.trustedMode=Trusted Mode (owner and trusted player access) gui.reactor.injectionRate=Injection Rate @@ -663,6 +670,11 @@ gui.digitalMiner.missingBlock=Missing block recipe.mekanismShaped=Shaped recipe.mekanismShapeless=Shapeless +//Security types +security.public=Public +security.private=Private +security.trusted=Trusted + //Item and block tooltip text tooltip.configurator.configurate=Configurate tooltip.configurator.empty=Empty @@ -776,6 +788,7 @@ tooltip.SuperheatingElement=A modular, somewhat dangerous radiator that is capab tooltip.PressureDisperser=A block used disperse steam throughout a multiblock structure. These should form a gapless, horizontal plane in order to properly control steam flow. tooltip.BoilerCasing=A pressure-resistant, dense casing used in the creation of a Thermoelectric Boiler multiblock. tooltip.BoilerValve=A valve that can be placed on a Thermoelectric Boiler multiblock, allowing for the insertion of energy and water along with the extraction of produced steam. +tooltip.SecurityDesk=A central control hub for managing the security of all your owned machinery. tooltip.EnrichmentChamber=A simple machine used to enrich ores into two of their dust counterparts, as well as perform many other operations. tooltip.OsmiumCompressor=A fairly advanced machine used to compress osmium into various dusts in order to create their ingot counterparts.