From cbcb465c972eda3b8f21d1bad4e01bdf519c183c Mon Sep 17 00:00:00 2001 From: Modmuss50 Date: Mon, 25 Dec 2017 00:18:43 +0000 Subject: [PATCH] Added support for individual slot configuration * start work on slot config * More slot work * More gui work for slot config * Remove old sided code * More slot work * More slot memes * Stuff seems to be working :) * Start work on auto input / output * Slot IO check boxes now work * Fix buttons at different screen resolutions * Improve close button * Gui polish * Fix multiblock hologram rendering * More fixes + changes * Cleanup + output fix --- .../java/techreborn/client/gui/GuiBase.java | 61 ++- .../client/gui/GuiBlastFurnace.java | 2 +- .../client/gui/GuiDistillationTower.java | 6 +- .../client/gui/GuiImplosionCompressor.java | 2 +- .../client/gui/GuiIndustrialGrinder.java | 2 +- .../client/gui/GuiIndustrialSawmill.java | 6 +- .../client/gui/GuiVacuumFreezer.java | 6 +- .../java/techreborn/client/gui/TRBuilder.java | 47 ++- .../client/gui/slot/GuiSlotConfiguration.java | 169 ++++++++ .../gui/slot/elements/ButtonElement.java | 17 + .../gui/slot/elements/CheckBoxElement.java | 54 +++ .../gui/slot/elements/ConfigSlotElement.java | 80 ++++ .../client/gui/slot/elements/ElementBase.java | 363 ++++++++++++++++++ .../client/gui/slot/elements/ISprite.java | 7 + .../client/gui/slot/elements/LICENSE | 21 + .../gui/slot/elements/OffsetSprite.java | 45 +++ .../client/gui/slot/elements/README.md | 3 + .../slot/elements/SlotConfigPopupElement.java | 194 ++++++++++ .../client/gui/slot/elements/SlotElement.java | 38 ++ .../client/gui/slot/elements/SlotType.java | 45 +++ .../client/gui/slot/elements/Sprite.java | 145 +++++++ .../gui/slot/elements/SpriteContainer.java | 54 +++ src/main/java/techreborn/init/ModBlocks.java | 4 +- .../init/recipes/CraftingTableRecipes.java | 8 +- .../java/techreborn/items/ItemUpgrades.java | 71 +--- .../java/techreborn/proxies/ClientProxy.java | 2 + .../tiles/TileAssemblingMachine.java | 19 +- .../tiles/TileAutoCraftingTable.java | 25 +- .../java/techreborn/tiles/TileChargeOMat.java | 27 +- .../techreborn/tiles/TileChemicalReactor.java | 32 +- .../techreborn/tiles/TileChunkLoader.java | 2 +- .../tiles/TileIndustrialCentrifuge.java | 20 +- .../tiles/TileIndustrialElectrolyzer.java | 25 +- .../tiles/TileIronAlloyFurnace.java | 14 - .../techreborn/tiles/TileIronFurnace.java | 26 +- .../tiles/TileMatterFabricator.java | 19 +- .../techreborn/tiles/TileQuantumTank.java | 2 +- .../techreborn/tiles/TileRollingMachine.java | 19 +- .../techreborn/tiles/TileScrapboxinator.java | 24 +- .../techreborn/tiles/cable/TileCable.java | 6 +- .../TileFusionControlComputer.java | 25 -- .../generator/TileBaseFluidGenerator.java | 2 +- .../generator/TileCreativeSolarPanel.java | 2 +- .../tiles/generator/TileDragonEggSyphon.java | 2 +- .../generator/TileSolidFuelGenerator.java | 12 +- .../multiblock/TileDistillationTower.java | 15 - .../multiblock/TileImplosionCompressor.java | 17 +- .../TileIndustrialBlastFurnace.java | 20 +- .../multiblock/TileIndustrialGrinder.java | 20 +- .../multiblock/TileIndustrialSawmill.java | 19 +- .../tiles/multiblock/TileVacuumFreezer.java | 17 +- .../tiles/storage/TileEnergyStorage.java | 17 +- .../tiles/teir1/TileAlloySmelter.java | 23 +- .../tiles/teir1/TileCompressor.java | 22 +- .../tiles/teir1/TileElectricFurnace.java | 46 +-- .../techreborn/tiles/teir1/TileExtractor.java | 21 +- .../techreborn/tiles/teir1/TileGrinder.java | 21 +- .../techreborn/tiles/teir1/TileRecycler.java | 22 -- .../tiles/transformers/TileTransformer.java | 2 +- .../techreborn/textures/gui/elements.png | Bin 0 -> 12076 bytes .../techreborn/textures/gui/gui_sheet.png | Bin 18127 -> 15319 bytes 61 files changed, 1396 insertions(+), 641 deletions(-) create mode 100644 src/main/java/techreborn/client/gui/slot/GuiSlotConfiguration.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/ButtonElement.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/CheckBoxElement.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/ConfigSlotElement.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/ElementBase.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/ISprite.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/LICENSE create mode 100644 src/main/java/techreborn/client/gui/slot/elements/OffsetSprite.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/README.md create mode 100644 src/main/java/techreborn/client/gui/slot/elements/SlotConfigPopupElement.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/SlotElement.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/SlotType.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/Sprite.java create mode 100644 src/main/java/techreborn/client/gui/slot/elements/SpriteContainer.java create mode 100644 src/main/resources/assets/techreborn/textures/gui/elements.png diff --git a/src/main/java/techreborn/client/gui/GuiBase.java b/src/main/java/techreborn/client/gui/GuiBase.java index 6f059b200..72f5b4d26 100644 --- a/src/main/java/techreborn/client/gui/GuiBase.java +++ b/src/main/java/techreborn/client/gui/GuiBase.java @@ -26,15 +26,19 @@ package techreborn.client.gui; import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.resources.I18n; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; -import net.minecraft.client.resources.I18n; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; import reborncore.api.tile.IUpgradeable; +import reborncore.common.tile.TileLegacyMachineBase; import techreborn.client.container.builder.BuiltContainer; +import techreborn.client.gui.slot.GuiSlotConfiguration; import techreborn.client.gui.widget.GuiButtonPowerBar; +import java.io.IOException; + /** * Created by Prospector */ @@ -45,6 +49,7 @@ public class GuiBase extends GuiContainer { public TRBuilder builder = new TRBuilder(); public TileEntity tile; public BuiltContainer container; + public static boolean showSlotConfig = false; public GuiBase(EntityPlayer player, TileEntity tile, BuiltContainer container) { super(container); @@ -106,6 +111,7 @@ public class GuiBase extends GuiContainer { @Override public void initGui() { super.initGui(); + GuiSlotConfiguration.init(this); } @Override @@ -121,6 +127,8 @@ public class GuiBase extends GuiContainer { builder.drawUpgrades(this, upgradeable, guiLeft, guiTop); } } + builder.drawSlotTab(this, guiLeft, guiTop, mouseX, mouseY); + } public boolean drawPlayerSlots() { @@ -135,6 +143,9 @@ public class GuiBase extends GuiContainer { @Override protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) { drawTitle(); + if(showSlotConfig){ + GuiSlotConfiguration.draw(this, mouseX, mouseY); + } } @Override @@ -179,6 +190,54 @@ public class GuiBase extends GuiContainer { buttonList.add(new GuiButtonPowerBar(id, x + factorX, y + factorY, this, layer)); } + @Override + protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException { + if(showSlotConfig){ + if(GuiSlotConfiguration.mouseClicked(mouseX, mouseY, mouseButton, this)){ + return; + } + } + super.mouseClicked(mouseX, mouseY, mouseButton); + } + + @Override + protected void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) { + if(showSlotConfig){ + GuiSlotConfiguration.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick, this); + } + super.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick); + } + + @Override + protected void mouseReleased(int mouseX, int mouseY, int state) { + if(isPointInRegion(-26, 84, 30, 30, mouseX, mouseY)){ + showSlotConfig = !showSlotConfig; + if(!showSlotConfig){ + GuiSlotConfiguration.reset(); + } + } + if(showSlotConfig){ + if(GuiSlotConfiguration.mouseReleased(mouseX, mouseY, state, this)){ + return; + } + } + super.mouseReleased(mouseX, mouseY, state); + } + + @Override + public void onGuiClosed() { + showSlotConfig = false; + super.onGuiClosed(); + } + + public boolean isPointInRect(int rectX, int rectY, int rectWidth, int rectHeight, int pointX, int pointY) { + return super.isPointInRegion(rectX, rectY, rectWidth, rectHeight, pointX, pointY); + } + + public TileLegacyMachineBase getMachine(){ + return (TileLegacyMachineBase) tile; + } + //TODO public enum SlotRender { STANDARD, OUTPUT, NONE, SPRITE; diff --git a/src/main/java/techreborn/client/gui/GuiBlastFurnace.java b/src/main/java/techreborn/client/gui/GuiBlastFurnace.java index c1d11bdaf..d6c2b8abd 100644 --- a/src/main/java/techreborn/client/gui/GuiBlastFurnace.java +++ b/src/main/java/techreborn/client/gui/GuiBlastFurnace.java @@ -108,7 +108,7 @@ public class GuiBlastFurnace extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/GuiDistillationTower.java b/src/main/java/techreborn/client/gui/GuiDistillationTower.java index 37d19e3bf..9592a7004 100644 --- a/src/main/java/techreborn/client/gui/GuiDistillationTower.java +++ b/src/main/java/techreborn/client/gui/GuiDistillationTower.java @@ -24,8 +24,6 @@ package techreborn.client.gui; -import java.io.IOException; - import net.minecraft.block.state.IBlockState; import net.minecraft.client.gui.GuiButton; import net.minecraft.client.renderer.GlStateManager; @@ -41,6 +39,8 @@ import techreborn.init.ModBlocks; import techreborn.proxies.ClientProxy; import techreborn.tiles.multiblock.TileDistillationTower; +import java.io.IOException; + public class GuiDistillationTower extends GuiBase { public TileDistillationTower tile; @@ -105,7 +105,7 @@ public class GuiDistillationTower extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/GuiImplosionCompressor.java b/src/main/java/techreborn/client/gui/GuiImplosionCompressor.java index 419c5e5bf..92d7b2196 100644 --- a/src/main/java/techreborn/client/gui/GuiImplosionCompressor.java +++ b/src/main/java/techreborn/client/gui/GuiImplosionCompressor.java @@ -107,7 +107,7 @@ public class GuiImplosionCompressor extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/GuiIndustrialGrinder.java b/src/main/java/techreborn/client/gui/GuiIndustrialGrinder.java index f2798fb84..1cec322e1 100644 --- a/src/main/java/techreborn/client/gui/GuiIndustrialGrinder.java +++ b/src/main/java/techreborn/client/gui/GuiIndustrialGrinder.java @@ -111,7 +111,7 @@ public class GuiIndustrialGrinder extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/GuiIndustrialSawmill.java b/src/main/java/techreborn/client/gui/GuiIndustrialSawmill.java index 04c4665cb..44d10606d 100644 --- a/src/main/java/techreborn/client/gui/GuiIndustrialSawmill.java +++ b/src/main/java/techreborn/client/gui/GuiIndustrialSawmill.java @@ -24,8 +24,6 @@ package techreborn.client.gui; -import java.io.IOException; - import net.minecraft.block.state.IBlockState; import net.minecraft.client.gui.GuiButton; import net.minecraft.entity.player.EntityPlayer; @@ -41,6 +39,8 @@ import techreborn.init.ModBlocks; import techreborn.proxies.ClientProxy; import techreborn.tiles.multiblock.TileIndustrialSawmill; +import java.io.IOException; + public class GuiIndustrialSawmill extends GuiBase { TileIndustrialSawmill tile; @@ -110,7 +110,7 @@ public class GuiIndustrialSawmill extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/GuiVacuumFreezer.java b/src/main/java/techreborn/client/gui/GuiVacuumFreezer.java index be5d8d9d7..b968b29bf 100644 --- a/src/main/java/techreborn/client/gui/GuiVacuumFreezer.java +++ b/src/main/java/techreborn/client/gui/GuiVacuumFreezer.java @@ -24,8 +24,6 @@ package techreborn.client.gui; -import java.io.IOException; - import net.minecraft.block.state.IBlockState; import net.minecraft.client.gui.GuiButton; import net.minecraft.entity.player.EntityPlayer; @@ -39,6 +37,8 @@ import techreborn.init.ModBlocks; import techreborn.proxies.ClientProxy; import techreborn.tiles.multiblock.TileVacuumFreezer; +import java.io.IOException; + public class GuiVacuumFreezer extends GuiBase { TileVacuumFreezer tile; @@ -102,7 +102,7 @@ public class GuiVacuumFreezer extends GuiBase { @Override public void actionPerformed(final GuiButton button) throws IOException { super.actionPerformed(button); - if (button.id == 212) { + if (button.id == 212 && !GuiBase.showSlotConfig) { if (ClientProxy.multiblockRenderEvent.currentMultiblock == null) { { // This code here makes a basic multiblock and then sets to the selected one. diff --git a/src/main/java/techreborn/client/gui/TRBuilder.java b/src/main/java/techreborn/client/gui/TRBuilder.java index e4ab719de..4910f3f2f 100644 --- a/src/main/java/techreborn/client/gui/TRBuilder.java +++ b/src/main/java/techreborn/client/gui/TRBuilder.java @@ -27,23 +27,30 @@ package techreborn.client.gui; import net.minecraft.client.Minecraft; import net.minecraft.client.gui.GuiScreen; import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.RenderItem; import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.resources.I18n; +import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; import net.minecraft.util.text.TextFormatting; -import net.minecraft.client.resources.I18n; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fml.client.config.GuiUtils; import net.minecraftforge.fml.common.Loader; +import org.lwjgl.opengl.GL11; import reborncore.api.tile.IUpgradeable; import reborncore.client.guibuilder.GuiBuilder; import reborncore.common.powerSystem.PowerSystem; +import techreborn.init.ModItems; import techreborn.lib.ModInfo; import techreborn.proxies.ClientProxy; import java.util.ArrayList; import java.util.List; +import static net.minecraft.item.ItemStack.EMPTY; + /** * Created by Prospector */ @@ -86,6 +93,9 @@ public class TRBuilder extends GuiBuilder { } public void drawProgressBar(GuiBase gui, int progress, int maxProgress, int x, int y, int mouseX, int mouseY, ProgressDirection direction, GuiBase.Layer layer) { + if(GuiBase.showSlotConfig){ + return; + } if (layer == GuiBase.Layer.BACKGROUND) { x += gui.getGuiLeft(); y += gui.getGuiTop(); @@ -189,6 +199,9 @@ public class TRBuilder extends GuiBuilder { } public void drawJEIButton(GuiBase gui, int x, int y, GuiBase.Layer layer) { + if(GuiBase.showSlotConfig){ + return; + } if (Loader.isModLoaded("jei")) { if (layer == GuiBase.Layer.BACKGROUND) { x += gui.getGuiLeft(); @@ -200,6 +213,9 @@ public class TRBuilder extends GuiBuilder { } public void drawHologramButton(GuiBase gui, int x, int y, int mouseX, int mouseY, GuiBase.Layer layer) { + if(GuiBase.showSlotConfig){ + return; + } if (layer == GuiBase.Layer.BACKGROUND) { x += gui.getGuiLeft(); y += gui.getGuiTop(); @@ -299,6 +315,9 @@ public class TRBuilder extends GuiBuilder { } public void drawMultiblockMissingBar(GuiBase gui, GuiBase.Layer layer) { + if(GuiBase.showSlotConfig){ + return; + } int x = 0; int y = 4; if (layer == GuiBase.Layer.BACKGROUND) { @@ -364,6 +383,32 @@ public class TRBuilder extends GuiBuilder { gui.drawTexturedModalRect(posX - 27, posY + 4, 126, 151, 30, 87); } + public void drawSlotTab(GuiScreen gui, int posX, int posY, int mouseX, int mouseY){ + Minecraft.getMinecraft().getTextureManager().bindTexture(GUI_SHEET); + gui.drawTexturedModalRect(posX - 26, posY + 84, 157, 148, 30, 30); + renderItemStack(new ItemStack(ModItems.WRENCH), posX - 19, posY + 92); + if (isInRect(posX - 19, posY + 92, 12, 12, mouseX, mouseY)) { + List list = new ArrayList<>(); + list.add("Configure slots"); + net.minecraftforge.fml.client.config.GuiUtils.drawHoveringText(list, mouseX, mouseY, gui.width, gui.height, -1, gui.mc.fontRenderer); + GlStateManager.disableLighting(); + GlStateManager.color(1, 1, 1, 1); + } + } + + public void renderItemStack(ItemStack stack, int x, int y) { + if (stack != EMPTY) { + GL11.glEnable(GL11.GL_BLEND); + GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + + RenderItem itemRenderer = Minecraft.getMinecraft().getRenderItem(); + itemRenderer.renderItemAndEffectIntoGUI(stack, x, y); + + GL11.glDisable(GL11.GL_LIGHTING); + } + } + public void drawScrapSlot(GuiScreen gui, int posX, int posY) { Minecraft.getMinecraft().getTextureManager().bindTexture(GUI_SHEET); gui.drawTexturedModalRect(posX, posY, 150, 0, 18, 18); diff --git a/src/main/java/techreborn/client/gui/slot/GuiSlotConfiguration.java b/src/main/java/techreborn/client/gui/slot/GuiSlotConfiguration.java new file mode 100644 index 000000000..f3a9708ec --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/GuiSlotConfiguration.java @@ -0,0 +1,169 @@ +package techreborn.client.gui.slot; + +import com.google.common.collect.Lists; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.inventory.Slot; +import net.minecraftforge.client.event.GuiScreenEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import org.lwjgl.input.Keyboard; +import reborncore.client.gui.GuiUtil; +import techreborn.client.container.builder.BuiltContainer; +import techreborn.client.gui.GuiBase; +import techreborn.client.gui.slot.elements.ConfigSlotElement; +import techreborn.client.gui.slot.elements.ElementBase; +import techreborn.client.gui.slot.elements.SlotType; + +import java.awt.*; +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.stream.Collectors; + +public class GuiSlotConfiguration { + + static HashMap slotElementMap = new HashMap<>(); + + public static int slectedSlot = 0; + + public static void reset() { + slectedSlot = -1; + } + + public static void init(GuiBase guiBase) { + reset(); + slotElementMap.clear(); + + BuiltContainer container = guiBase.container; + for (Slot slot : container.inventorySlots) { + if (guiBase.tile != slot.inventory) { + continue; + } + ConfigSlotElement slotElement = new ConfigSlotElement(guiBase.getMachine(), slot.getSlotIndex(), SlotType.NORMAL, slot.xPos - guiBase.guiLeft + 50, slot.yPos - guiBase.guiTop - 25, guiBase); + slotElementMap.put(slot.getSlotIndex(), slotElement); + } + + } + + public static void draw(GuiBase guiBase, int mouseX, int mouseY) { + BuiltContainer container = guiBase.container; + for (Slot slot : container.inventorySlots) { + if (guiBase.tile != slot.inventory) { + continue; + } + GlStateManager.color(255, 0, 0); + Color color = new Color(255, 0, 0, 128); + GuiUtil.drawGradientRect(slot.xPos - 1, slot.yPos - 1, 18, 18, color.getRGB(), color.getRGB()); + GlStateManager.color(255, 255, 255); + } + + if (slectedSlot != -1) { + slotElementMap.get(slectedSlot).draw(guiBase); + } + } + + public static List getVisibleElements() { + if(slectedSlot == -1){ + return Collections.emptyList(); + } + return slotElementMap.values().stream() + .filter(configSlotElement -> configSlotElement.getId() == slectedSlot) + .collect(Collectors.toList()); + } + + //Allows closing of the widget with the escape key + @SubscribeEvent + public static void keyboardEvent(GuiScreenEvent.KeyboardInputEvent event){ + if(!getVisibleElements().isEmpty() && Keyboard.getEventKey() == Keyboard.KEY_ESCAPE){ + slectedSlot = -1; + event.setCanceled(true); + } + } + + public static boolean mouseClicked(int mouseX, int mouseY, int mouseButton, GuiBase guiBase) throws IOException { + if (mouseButton == 0) { + for (ConfigSlotElement configSlotElement : getVisibleElements()) { + for (ElementBase element : configSlotElement.elements) { + if (element.isInRect(guiBase, element.x, element.y, element.getWidth(guiBase.getMachine()), element.getHeight(guiBase.getMachine()), mouseX, mouseY)) { + element.isPressing = true; + boolean action = element.onStartPress(guiBase.getMachine(), guiBase, mouseX, mouseY); + for (ElementBase e : getVisibleElements()) { + if (e != element) { + e.isPressing = false; + } + } + if (action) + break; + } else { + element.isPressing = false; + } + } + } + } + BuiltContainer container = guiBase.container; + + if(getVisibleElements().isEmpty()) { + for (Slot slot : container.inventorySlots) { + if (guiBase.tile != slot.inventory) { + continue; + } + if (guiBase.isPointInRect(slot.xPos, slot.yPos, 18, 18, mouseX, mouseY)) { + slectedSlot = slot.getSlotIndex(); + return true; + } + } + } + return !getVisibleElements().isEmpty(); + } + + public static void mouseClickMove(int mouseX, int mouseY, int mouseButton, long timeSinceLastClick, GuiBase guiBase) { + if (mouseButton == 0) { + for (ConfigSlotElement configSlotElement : getVisibleElements()) { + for (ElementBase element : configSlotElement.elements) { + if (element.isInRect(guiBase, element.x, element.y, element.getWidth(guiBase.getMachine()), element.getHeight(guiBase.getMachine()), mouseX, mouseY)) { + element.isDragging = true; + boolean action = element.onDrag(guiBase.getMachine(), guiBase, mouseX, mouseY); + for (ElementBase e : getVisibleElements()) { + if (e != element) { + e.isDragging = false; + } + } + if (action) + break; + } else { + element.isDragging = false; + } + } + } + } + } + + public static boolean mouseReleased(int mouseX, int mouseY, int mouseButton, GuiBase guiBase) { + boolean clicked = false; + if (mouseButton == 0) { + for (ConfigSlotElement configSlotElement : getVisibleElements()) { + if (configSlotElement.isInRect(guiBase, configSlotElement.x, configSlotElement.y, configSlotElement.getWidth(guiBase.getMachine()), configSlotElement.getHeight(guiBase.getMachine()), mouseX, mouseY)) { + clicked = true; + } + for (ElementBase element : Lists.reverse(configSlotElement.elements)) { + if (element.isInRect(guiBase, element.x, element.y, element.getWidth(guiBase.getMachine()), element.getHeight(guiBase.getMachine()), mouseX, mouseY)) { + element.isReleasing = true; + boolean action = element.onRelease(guiBase.getMachine(), guiBase, mouseX, mouseY); + for (ElementBase e : getVisibleElements()) { + if (e != element) { + e.isReleasing = false; + } + } + if (action) + clicked = true; + break; + } else { + element.isReleasing = false; + } + } + } + } + return clicked; + } + +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/ButtonElement.java b/src/main/java/techreborn/client/gui/slot/elements/ButtonElement.java new file mode 100644 index 000000000..02104a8e0 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/ButtonElement.java @@ -0,0 +1,17 @@ +package techreborn.client.gui.slot.elements; + +public class ButtonElement extends ElementBase { + private Sprite.Button buttonSprite; + + public ButtonElement(int x, int y, Sprite.Button buttonSprite) { + super(x, y, buttonSprite.getNormal()); + this.buttonSprite = buttonSprite; + this.addUpdateAction((gui, element) -> { + if (isHovering) { + element.container.setSprite(0, buttonSprite.getHovered()); + } else { + element.container.setSprite(0, buttonSprite.getNormal()); + } + }); + } +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/CheckBoxElement.java b/src/main/java/techreborn/client/gui/slot/elements/CheckBoxElement.java new file mode 100644 index 000000000..fa14fe805 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/CheckBoxElement.java @@ -0,0 +1,54 @@ +package techreborn.client.gui.slot.elements; + +import reborncore.common.tile.TileLegacyMachineBase; +import techreborn.client.gui.GuiBase; + +public class CheckBoxElement extends ElementBase { + public String label, type; + public int labelColor, slotID; + TileLegacyMachineBase machineBase; + + private Sprite.CheckBox checkBoxSprite; + + public CheckBoxElement(String label, int labelColor, int x, int y, String type, int slotID, Sprite.CheckBox checkBoxSprite, TileLegacyMachineBase machineBase) { + super(x, y, checkBoxSprite.getNormal()); + this.checkBoxSprite = checkBoxSprite; + this.type = type; + this.slotID = slotID; + this.machineBase = machineBase; + this.label = label; + this.labelColor = labelColor; + if (isTicked()) { + container.setSprite(0, checkBoxSprite.getTicked()); + } else { + container.setSprite(0, checkBoxSprite.getNormal()); + } + this.addPressAction((element, gui, provider, mouseX, mouseY) -> { + if (isTicked()) { + element.container.setSprite(0, checkBoxSprite.getTicked()); + } else { + element.container.setSprite(0, checkBoxSprite.getNormal()); + } + return true; + }); + } + + @Override + public void draw(GuiBase gui) { + // super.draw(gui); + ISprite sprite = checkBoxSprite.getNormal(); + if(isTicked()){ + sprite = checkBoxSprite.getTicked(); + } + drawSprite(gui, sprite, x, y ); + drawString(gui, label, x + checkBoxSprite.getNormal().width + 5, ((y + getHeight(gui.getMachine()) / 2) - (gui.mc.fontRenderer.FONT_HEIGHT / 2)), labelColor); + } + + public boolean isTicked() { + if(type.equalsIgnoreCase("output")){ + return machineBase.slotConfiguration.getSlotDetails(slotID).autoOutput(); + } + return machineBase.slotConfiguration.getSlotDetails(slotID).autoInput(); + } + +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/ConfigSlotElement.java b/src/main/java/techreborn/client/gui/slot/elements/ConfigSlotElement.java new file mode 100644 index 000000000..9decb3307 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/ConfigSlotElement.java @@ -0,0 +1,80 @@ +package techreborn.client.gui.slot.elements; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.RenderItem; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import reborncore.common.tile.SlotConfiguration; +import techreborn.client.gui.GuiBase; +import techreborn.client.gui.slot.GuiSlotConfiguration; + +import java.util.ArrayList; +import java.util.List; + +public class ConfigSlotElement extends ElementBase { + SlotType type; + IInventory inventory; + int id; + public List elements = new ArrayList<>(); + + + public ConfigSlotElement(IInventory slotInventory, int slotId, SlotType type, int x, int y, GuiBase gui) { + super(x, y, type.getButtonSprite()); + this.type = type; + this.inventory = slotInventory; + this.id = slotId; + + SlotConfigPopupElement popupElement; + + elements.add(popupElement = new SlotConfigPopupElement(this.id, x - 22, y - 22, this)); + elements.add(new ButtonElement(x + 37, y - 25, Sprite.EXIT_BUTTON).addReleaseAction((element, gui1, provider, mouseX, mouseY) -> { + GuiSlotConfiguration.slectedSlot = -1; + return true; + })); + + SlotConfiguration.SlotConfigHolder slotConfigHolder = gui.getMachine().slotConfiguration.getSlotDetails(id); + + elements.add(new CheckBoxElement("Auto Input", 0xFFFFFFFF, x - 26, y + 42, "input", slotId, Sprite.LIGHT_CHECK_BOX, gui.getMachine()).addPressAction((element, gui12, provider, mouseX, mouseY) -> { + popupElement.updateCheckBox((CheckBoxElement) element, "input", gui12); + return true; + })); + elements.add(new CheckBoxElement("Auto Output", 0xFFFFFFFF, x - 26, y + 57,"output", slotId, Sprite.LIGHT_CHECK_BOX, gui.getMachine()).addPressAction((element, gui13, provider, mouseX, mouseY) -> { + popupElement.updateCheckBox((CheckBoxElement) element, "output", gui13); + return true; + })); + } + + @Override + public void draw(GuiBase gui) { + super.draw(gui); + ItemStack stack = inventory.getStackInSlot(id); + int xPos = x + 1 + gui.guiLeft; + int yPos = y + 1 + gui.guiTop; + + GlStateManager.enableDepth(); + GlStateManager.pushMatrix(); + GlStateManager.enableBlend(); + GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + RenderItem renderItem = Minecraft.getMinecraft().getRenderItem(); + renderItem.renderItemAndEffectIntoGUI(gui.mc.player, stack, xPos, yPos); + renderItem.renderItemOverlayIntoGUI(gui.mc.fontRenderer, stack, xPos, yPos, null); + GlStateManager.disableDepth(); + GlStateManager.disableLighting(); + GlStateManager.popMatrix(); + if (isHovering) { + drawSprite(gui, type.getButtonHoverOverlay(), x, y); + } + elements.forEach(elementBase -> elementBase.draw(gui)); + } + + public SlotType getType() { + return type; + } + + public int getId() { + return id; + } +} \ No newline at end of file diff --git a/src/main/java/techreborn/client/gui/slot/elements/ElementBase.java b/src/main/java/techreborn/client/gui/slot/elements/ElementBase.java new file mode 100644 index 000000000..b73e04197 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/ElementBase.java @@ -0,0 +1,363 @@ +package techreborn.client.gui.slot.elements; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.*; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.text.TextFormatting; +import reborncore.client.guibuilder.GuiBuilder; +import reborncore.common.tile.TileLegacyMachineBase; +import techreborn.client.gui.GuiBase; +import techreborn.lib.ModInfo; + +import java.util.ArrayList; +import java.util.List; + +public class ElementBase { + + public int x; + public int y; + public boolean isHovering = false; + public boolean isDragging = false; + public boolean isPressing = false; + public boolean isReleasing = false; + public boolean startPressLast = false; + public boolean isHoveringLast = false; + public boolean isDraggingLast = false; + public boolean isPressingLast = false; + public boolean isReleasingLast = false; + public List hoverActions = new ArrayList<>(); + public List dragActions = new ArrayList<>(); + public List startPressActions = new ArrayList<>(); + public List pressActions = new ArrayList<>(); + public List releaseActions = new ArrayList<>(); + public SpriteContainer container; + public List updateActions = new ArrayList<>(); + public List buttonUpdate = new ArrayList<>(); + private int width; + private int height; + + public static final ResourceLocation MECH_ELEMENTS = new ResourceLocation(ModInfo.MOD_ID, "textures/gui/elements.png"); + + public ElementBase(int x, int y, SpriteContainer container) { + this.container = container; + this.x = x; + this.y = y; + } + + public ElementBase(int x, int y, ISprite... sprites) { + this.container = new SpriteContainer(); + for (ISprite sprite : sprites) { + container.addSprite(sprite); + } + this.x = x; + this.y = y; + } + + public ElementBase(int x, int y, int width, int height) { + this.container = new SpriteContainer(); + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public ElementBase(int x, int y, int width, int height, SpriteContainer container) { + this.container = container; + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public ElementBase(int x, int y, int width, int height, ISprite... sprites) { + this.container = new SpriteContainer(); + for (ISprite sprite : sprites) { + container.addSprite(sprite); + } + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + public SpriteContainer getSpriteContainer() { + return container; + } + + public void adjustDimensions(TileLegacyMachineBase provider) { + if (container.offsetSprites != null) { + for (OffsetSprite offsetSprite : container.offsetSprites) { + if (offsetSprite.getSprite().getSprite(provider).width + offsetSprite.getOffsetX(provider) > this.width) { + this.width = offsetSprite.getSprite().getSprite(provider).width + offsetSprite.getOffsetX(provider); + } + if (offsetSprite.getSprite().getSprite(provider).height + offsetSprite.getOffsetY(provider) > this.height) { + this.height = offsetSprite.getSprite().getSprite(provider).height + offsetSprite.getOffsetY(provider); + } + } + } + } + + public void draw(GuiBase gui) { + for (OffsetSprite sprite : getSpriteContainer().offsetSprites) { + drawSprite(gui, sprite.getSprite(), x + sprite.getOffsetX(gui.getMachine()), y + sprite.getOffsetY(gui.getMachine())); + } + } + + public void renderUpdate(GuiBase gui) { + isHoveringLast = isHovering; + isPressingLast = isPressing; + isDraggingLast = isDragging; + isReleasingLast = isReleasing; + } + + public void update(GuiBase gui) { + for (UpdateAction action : updateActions) { + action.update(gui, this); + } + } + + public ElementBase addUpdateAction(UpdateAction action) { + updateActions.add(action); + return this; + } + + public ElementBase setWidth(int width) { + this.width = width; + return this; + } + + public ElementBase setHeight(int height) { + this.height = height; + return this; + } + + public int getX() { + return x; + } + + public ElementBase setX(int x) { + this.x = x; + return this; + } + + public int getY() { + return y; + } + + public ElementBase setY(int y) { + this.y = y; + return this; + } + + public int getWidth(TileLegacyMachineBase provider) { + adjustDimensions(provider); + return width; + } + + public int getHeight(TileLegacyMachineBase provider) { + adjustDimensions(provider); + return height; + } + + public ElementBase addHoverAction(ElementBase.Action action) { + this.hoverActions.add(action); + return this; + } + + public ElementBase addDragAction(ElementBase.Action action) { + this.dragActions.add(action); + return this; + } + + public ElementBase addStartPressAction(ElementBase.Action action) { + this.startPressActions.add(action); + return this; + } + + public ElementBase addPressAction(ElementBase.Action action) { + this.pressActions.add(action); + return this; + } + + public ElementBase addReleaseAction(ElementBase.Action action) { + this.releaseActions.add(action); + return this; + } + + public boolean onHover(TileLegacyMachineBase provider, GuiBase gui, int mouseX, int mouseY) { + for (ElementBase.Action action : hoverActions) { + action.execute(this, gui, provider, mouseX, mouseY); + } + return !hoverActions.isEmpty(); + } + + public boolean onDrag(TileLegacyMachineBase provider, GuiBase gui, int mouseX, int mouseY) { + for (ElementBase.Action action : dragActions) { + action.execute(this, gui, provider, mouseX, mouseY); + } + return !dragActions.isEmpty(); + } + + public boolean onStartPress(TileLegacyMachineBase provider, GuiBase gui, int mouseX, int mouseY) { + for (ElementBase.Action action : startPressActions) { + action.execute(this, gui, provider, mouseX, mouseY); + } + return !startPressActions.isEmpty(); + } + + public boolean onRelease(TileLegacyMachineBase provider, GuiBase gui, int mouseX, int mouseY) { + for (ElementBase.Action action : releaseActions) { + if(action.execute(this, gui, provider, mouseX, mouseY)){ + return true; + } + } + if (isPressing) { + for (ElementBase.Action action : pressActions) { + action.execute(this, gui, provider, mouseX, mouseY); + } + } + return !releaseActions.isEmpty() || !pressActions.isEmpty(); + } + + public interface Action { + boolean execute(ElementBase element, GuiBase gui, TileLegacyMachineBase provider, int mouseX, int mouseY); + } + + public interface UpdateAction { + void update(GuiBase gui, ElementBase element); + } + + public void drawRect(GuiBase gui, int x, int y, int width, int height, int colour) { + drawGradientRect(gui, x, y, width, height, colour, colour); + } + + /* + Taken from Gui + */ + public void drawGradientRect(GuiBase gui, int x, int y, int width, int height, int startColor, int endColor) { + x = adjustX(gui, x); + y = adjustY(gui, y); + + int left = x; + int top = y; + int right = x + width; + int bottom = y + height; + float f = (float) (startColor >> 24 & 255) / 255.0F; + float f1 = (float) (startColor >> 16 & 255) / 255.0F; + float f2 = (float) (startColor >> 8 & 255) / 255.0F; + float f3 = (float) (startColor & 255) / 255.0F; + float f4 = (float) (endColor >> 24 & 255) / 255.0F; + float f5 = (float) (endColor >> 16 & 255) / 255.0F; + float f6 = (float) (endColor >> 8 & 255) / 255.0F; + float f7 = (float) (endColor & 255) / 255.0F; + GlStateManager.disableTexture2D(); + GlStateManager.enableBlend(); + GlStateManager.disableAlpha(); + GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ZERO); + GlStateManager.shadeModel(7425); + Tessellator tessellator = Tessellator.getInstance(); + BufferBuilder vertexbuffer = tessellator.getBuffer(); + vertexbuffer.begin(7, DefaultVertexFormats.POSITION_COLOR); + vertexbuffer.pos((double) right, (double) top, (double) 0).color(f1, f2, f3, f).endVertex(); + vertexbuffer.pos((double) left, (double) top, (double) 0).color(f1, f2, f3, f).endVertex(); + vertexbuffer.pos((double) left, (double) bottom, (double) 0).color(f5, f6, f7, f4).endVertex(); + vertexbuffer.pos((double) right, (double) bottom, (double) 0).color(f5, f6, f7, f4).endVertex(); + tessellator.draw(); + GlStateManager.shadeModel(7424); + GlStateManager.disableBlend(); + GlStateManager.enableAlpha(); + GlStateManager.enableTexture2D(); + } + + public int adjustX(GuiBase gui, int x) { + return gui.guiLeft + x; + } + + public int adjustY(GuiBase gui, int y) { + return gui.guiTop + y; + } + + public boolean isInRect(GuiBase gui, int x, int y, int xSize, int ySize, int mouseX, int mouseY) { + return gui.isPointInRect(x + gui.guiLeft, y + gui.guiTop, xSize, ySize, mouseX, mouseY); + } + + public void drawString(GuiBase gui, String string, int x, int y, int color) { + x = adjustX(gui, x); + y = adjustY(gui, y); + gui.mc.fontRenderer.drawString(string, x, y, color); + } + + public void drawString(GuiBase gui, String string, int x, int y) { + drawString(gui, string, x, y, 16777215); + } + + public void setTextureSheet(ResourceLocation textureLocation) { + Minecraft.getMinecraft().getTextureManager().bindTexture(textureLocation); + } + + public void drawCenteredString(GuiBase gui, String string, int y, int colour) { + drawString(gui, string, (gui.getXSize() / 2 - gui.mc.fontRenderer.getStringWidth(string) / 2), y, colour); + } + + public void drawCenteredString(GuiBase gui, String string, int x, int y, int colour) { + drawString(gui, string, (x - gui.mc.fontRenderer.getStringWidth(string) / 2), y, colour); + } + + public int getStringWidth(String string) { + return Minecraft.getMinecraft().fontRenderer.getStringWidth(string); + } + + public void drawSprite(GuiBase gui, ISprite iSprite, int x, int y) { + Sprite sprite = iSprite.getSprite(gui.getMachine()); + if (sprite != null) { + if (sprite.hasTextureInfo()) { + GlStateManager.color(1F, 1F, 1F); + setTextureSheet(sprite.textureLocation); + gui.drawTexturedModalRect(x + gui.guiLeft, y + gui.guiTop, sprite.x, sprite.y, sprite.width, sprite.height); + } + if (sprite.hasStack()) { + GlStateManager.pushMatrix(); + GlStateManager.enableBlend(); + GlStateManager.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA); + RenderHelper.enableGUIStandardItemLighting(); + + RenderItem itemRenderer = Minecraft.getMinecraft().getRenderItem(); + itemRenderer.renderItemAndEffectIntoGUI(sprite.itemStack, x + gui.guiLeft, y + gui.guiTop); + + GlStateManager.disableLighting(); + GlStateManager.popMatrix(); + } + } + } + + public int getScaledBurnTime(int scale, int burnTime, int totalBurnTime) { + return (int) (((float) burnTime / (float) totalBurnTime) * scale); + } + + public TextFormatting getPercentageColour(int percentage) { + if (percentage <= 10) { + return TextFormatting.RED; + } else if (percentage >= 75) { + return TextFormatting.GREEN; + } else { + return TextFormatting.YELLOW; + } + } + + public int getPercentage(int MaxValue, int CurrentValue) { + if (CurrentValue == 0) + return 0; + return (int) ((CurrentValue * 100.0f) / MaxValue); + } + + public void drawDefaultBackground(GuiScreen gui, int x, int y, int width, int height) { + GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); + Minecraft.getMinecraft().getTextureManager().bindTexture(GuiBuilder.defaultTextureSheet); + gui.drawTexturedModalRect(x, y, 0, 0, width / 2, height / 2); + gui.drawTexturedModalRect(x + width / 2, y, 150 - width / 2, 0, width / 2, height / 2); + gui.drawTexturedModalRect(x, y + height / 2, 0, 150 - height / 2, width / 2, height / 2); + gui.drawTexturedModalRect(x + width / 2, y + height / 2, 150 - width / 2, 150 - height / 2, width / 2, height / 2); + } +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/ISprite.java b/src/main/java/techreborn/client/gui/slot/elements/ISprite.java new file mode 100644 index 000000000..c0393bd4e --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/ISprite.java @@ -0,0 +1,7 @@ +package techreborn.client.gui.slot.elements; + +import reborncore.common.tile.TileLegacyMachineBase; + +public interface ISprite { + Sprite getSprite(TileLegacyMachineBase provider); +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/LICENSE b/src/main/java/techreborn/client/gui/slot/elements/LICENSE new file mode 100644 index 000000000..9318f0db6 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Prospector + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/main/java/techreborn/client/gui/slot/elements/OffsetSprite.java b/src/main/java/techreborn/client/gui/slot/elements/OffsetSprite.java new file mode 100644 index 000000000..708bc1cd3 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/OffsetSprite.java @@ -0,0 +1,45 @@ +package techreborn.client.gui.slot.elements; + +import reborncore.common.tile.TileLegacyMachineBase; + +public class OffsetSprite { + public ISprite sprite; + public int offsetX = 0; + public int offsetY = 0; + + public OffsetSprite(ISprite sprite, int offsetX, int offsetY) { + this.sprite = sprite; + this.offsetX = offsetX; + this.offsetY = offsetY; + } + + public OffsetSprite(ISprite sprite) { + this.sprite = sprite; + } + + public OffsetSprite(Sprite sprite, TileLegacyMachineBase provider) { + this.sprite = sprite; + } + + public ISprite getSprite() { + return sprite; + } + + public int getOffsetX(TileLegacyMachineBase provider) { + return offsetX + sprite.getSprite(provider).offsetX; + } + + public OffsetSprite setOffsetX(int offsetX) { + this.offsetX = offsetX; + return this; + } + + public int getOffsetY(TileLegacyMachineBase provider) { + return offsetY + sprite.getSprite(provider).offsetY; + } + + public OffsetSprite setOffsetY(int offsetY) { + this.offsetY = offsetY; + return this; + } +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/README.md b/src/main/java/techreborn/client/gui/slot/elements/README.md new file mode 100644 index 000000000..b79269833 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/README.md @@ -0,0 +1,3 @@ +All code in this class was taken with permssion from https://github.com/ProfessorProspector/Mechanical-Construct + +A large ammount of modifications have taken place to allow it to work with techreborn. \ No newline at end of file diff --git a/src/main/java/techreborn/client/gui/slot/elements/SlotConfigPopupElement.java b/src/main/java/techreborn/client/gui/slot/elements/SlotConfigPopupElement.java new file mode 100644 index 000000000..519d1d474 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/SlotConfigPopupElement.java @@ -0,0 +1,194 @@ +package techreborn.client.gui.slot.elements; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.BlockRendererDispatcher; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.block.model.IBakedModel; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.init.Blocks; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.fml.client.FMLClientHandler; +import reborncore.RebornCore; +import reborncore.client.gui.GuiUtil; +import reborncore.common.blocks.BlockMachineBase; +import reborncore.common.network.NetworkManager; +import reborncore.common.network.packet.PacketIOSave; +import reborncore.common.network.packet.PacketSlotSave; +import reborncore.common.tile.SlotConfiguration; +import reborncore.common.tile.TileLegacyMachineBase; +import reborncore.common.util.MachineFacing; +import techreborn.client.gui.GuiBase; + +import java.awt.*; + +public class SlotConfigPopupElement extends ElementBase { + int id; + + ConfigSlotElement slotElement; + + + public SlotConfigPopupElement(int slotId, int x, int y, ConfigSlotElement slotElement) { + super(x, y, Sprite.SLOT_CONFIG_POPUP); + this.id = slotId; + this.slotElement = slotElement; + } + + @Override + public void draw(GuiBase gui) { + drawDefaultBackground(gui, adjustX(gui, getX() -8), adjustY(gui, getY() - 7), 84, 105); + super.draw(gui); + + TileLegacyMachineBase machine = ((TileLegacyMachineBase) gui.tile); + IBlockAccess blockAccess = machine.getWorld(); + BlockPos pos = machine.getPos(); + IBlockState state = blockAccess.getBlockState(pos); + IBlockState actualState = Blocks.DIRT.getDefaultState().getActualState(blockAccess, pos); + BlockRendererDispatcher dispatcher = FMLClientHandler.instance().getClient().getBlockRendererDispatcher(); + IBakedModel model = dispatcher.getBlockModelShapes().getModelForState(state.withProperty(BlockMachineBase.FACING, EnumFacing.NORTH)); + FMLClientHandler.instance().getClient().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 4, 23); //left + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 23, -12, -90F, 1F, 0F, 0F); //top + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 23, 23, -90F, 0F, 1F, 0F); //centre + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 23, 42, 90F, 1F, 0F, 0F); //bottom + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 26, 23, 180F, 0F, 1F, 0F); //right + drawState(gui, blockAccess, model, actualState, pos, dispatcher, 26, 42, 90F, 0F, 1F, 0F); //back + + + drawSlotSateColor(gui.getMachine(), MachineFacing.UP.getFacing(machine), id, 22, -1, gui); + drawSlotSateColor(gui.getMachine(), MachineFacing.FRONT.getFacing(machine), id, 22, 18, gui); + drawSlotSateColor(gui.getMachine(), MachineFacing.DOWN.getFacing(machine), id, 22, 37, gui); + drawSlotSateColor(gui.getMachine(), MachineFacing.RIGHT.getFacing(machine), id, 41, 18, gui); + drawSlotSateColor(gui.getMachine(), MachineFacing.BACK.getFacing(machine), id, 41, 37, gui); + drawSlotSateColor(gui.getMachine(), MachineFacing.LEFT.getFacing(machine), id, 3, 18, gui); + } + + @Override + public boolean onRelease(TileLegacyMachineBase provider, GuiBase gui, int mouseX, int mouseY) { + if(isInBox(23 , 4, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.UP.getFacing(provider), gui); + } else if(isInBox(23 , 23, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.FRONT.getFacing(provider), gui); + } else if(isInBox(42 , 23, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.RIGHT.getFacing(provider), gui); + } else if(isInBox(4 , 23, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.LEFT.getFacing(provider), gui); + } else if(isInBox(23 , 42, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.DOWN.getFacing(provider), gui); + } else if(isInBox(42 , 42, 16, 16, mouseX, mouseY, gui)){ + cyleSlotConfig(MachineFacing.BACK.getFacing(provider), gui); + } else { + return false; + } + return true; + } + + public void cyleSlotConfig(EnumFacing side, GuiBase guiBase){ + SlotConfiguration.SlotConfig currentSlot = guiBase.getMachine().slotConfiguration.getSlotDetails(id).getSideDetail(side); + + SlotConfiguration.SlotIO slotIO = new SlotConfiguration.SlotIO(currentSlot.getSlotIO().getIoConfig().getNext()); + SlotConfiguration.SlotConfig newConfig = new SlotConfiguration.SlotConfig(side, slotIO, id); + PacketSlotSave packetSlotSave = new PacketSlotSave(guiBase.tile.getPos(), newConfig); + NetworkManager.sendToServer(packetSlotSave); + } + + public void updateCheckBox(CheckBoxElement checkBoxElement, String type, GuiBase guiBase){ + SlotConfiguration.SlotConfigHolder configHolder = guiBase.getMachine().slotConfiguration.getSlotDetails(id); + boolean input = configHolder.autoInput(); + boolean output = configHolder.autoOutput(); + if(type.equalsIgnoreCase("input")){ + input = !configHolder.autoInput(); + } + if(type.equalsIgnoreCase("output")){ + output = !configHolder.autoOutput(); + } + + PacketIOSave packetSlotSave = new PacketIOSave(guiBase.tile.getPos(), id, input, output); + NetworkManager.sendToServer(packetSlotSave); + } + + private void drawSlotSateColor(TileLegacyMachineBase machineBase, EnumFacing side, int slotID, int inx, int iny, GuiBase gui){ + iny += 4; + int sx = inx + getX() + gui.guiLeft; + int sy = iny + getY() + gui.guiTop; + SlotConfiguration.SlotConfigHolder slotConfigHolder = machineBase.slotConfiguration.getSlotDetails(slotID); + if(slotConfigHolder == null){ + RebornCore.logHelper.debug("Humm, this isnt suppoed to happen"); + return; + } + SlotConfiguration.SlotConfig slotConfig = slotConfigHolder.getSideDetail(side); + Color color; + switch (slotConfig.getSlotIO().getIoConfig()){ + case NONE: + color = new Color(0, 0, 0, 0); + break; + case INPUT: + color = new Color(0, 0, 255, 128); + break; + case OUTPUT: + color = new Color(255, 69, 0, 128); + break; + default: + color = new Color(0, 0, 0, 0); + break; + } + GlStateManager.color(255, 255, 255); + GuiUtil.drawGradientRect(sx, sy, 18, 18, color.getRGB(), color.getRGB()); + GlStateManager.color(255, 255, 255); + + } + + private boolean isInBox(int rectX, int rectY, int rectWidth, int rectHeight, int pointX, int pointY, GuiBase guiBase){ + rectX += getX(); + rectY += getY(); + if(true){ + return isInRect(guiBase, rectX, rectY, rectWidth, rectHeight, pointX, pointY); + } + return (pointX - guiBase.getGuiLeft()) >= rectX - 1 && (pointX - guiBase.getGuiLeft()) < rectX + rectWidth + 1 && (pointY - guiBase.getGuiTop()) >= rectY - 1 && (pointY - guiBase.getGuiTop()) < rectY + rectHeight + 1; + } + + public void drawState(GuiBase gui, + IBlockAccess blockAccess, + IBakedModel model, + IBlockState actualState, + BlockPos pos, + BlockRendererDispatcher dispatcher, + int x, + int y, + float rotAngle, + float rotX, + float rotY, + float rotZ) { + + GlStateManager.pushMatrix(); + GlStateManager.enableDepth(); + GlStateManager.translate(8 + gui.guiLeft + this.x + x, 8 + gui.guiTop + this.y + y, 512); + GlStateManager.scale(16F, 16F, 16F); + GlStateManager.translate(0.5F, 0.5F, 0.5F); + GlStateManager.scale(-1, -1, -1); + if (rotAngle != 0) { + GlStateManager.rotate(rotAngle, rotX, rotY, rotZ); + } + dispatcher.getBlockModelRenderer().renderModelBrightness(model, actualState, 1F, false); + GlStateManager.disableDepth(); + GlStateManager.popMatrix(); + +/* GlStateManager.pushMatrix(); + GlStateManager.enableDepth(); + // GlStateManager.translate(8 + gui.xFactor + this.x + x, 8 + gui.yFactor + this.y + y, 1000); + GlStateManager.translate(gui.xFactor + this.x + x, gui.yFactor + this.y + y, 512); + if (rotAngle != 0) { + GlStateManager.rotate(rotAngle, rotX, rotY, rotZ); + } + GlStateManager.scale(16F, 16F, 16F); + GlStateManager.translate(-0.5F, -0.5F, -0.5F); + GlStateManager.scale(-1, -1, -1); + GlStateManager.disableDepth(); + GlStateManager.popMatrix();*/ + } + + public void drawState(GuiBase gui, IBlockAccess blockAccess, IBakedModel model, IBlockState actualState, BlockPos pos, BlockRendererDispatcher dispatcher, int x, int y) { + drawState(gui, blockAccess, model, actualState, pos, dispatcher, x, y, 0, 0, 0, 0); + } +} \ No newline at end of file diff --git a/src/main/java/techreborn/client/gui/slot/elements/SlotElement.java b/src/main/java/techreborn/client/gui/slot/elements/SlotElement.java new file mode 100644 index 000000000..68583773e --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/SlotElement.java @@ -0,0 +1,38 @@ +package techreborn.client.gui.slot.elements; + +import net.minecraftforge.items.ItemStackHandler; + +public class SlotElement extends ElementBase { + protected ItemStackHandler slotInventory; + protected SlotType type; + int slotId, slotX, slotY; + + public SlotElement(ItemStackHandler slotInventory, int slotId, int slotX, int slotY, SlotType type, int x, int y) { + super(x, y, type.getSprite()); + this.type = type; + this.slotInventory = slotInventory; + this.slotId = slotId; + this.slotX = slotX; + this.slotY = slotY; + } + + public SlotType getType() { + return type; + } + + public ItemStackHandler getSlotInventory() { + return slotInventory; + } + + public int getSlotId() { + return slotId; + } + + public int getSlotX() { + return slotX; + } + + public int getSlotY() { + return slotY; + } +} \ No newline at end of file diff --git a/src/main/java/techreborn/client/gui/slot/elements/SlotType.java b/src/main/java/techreborn/client/gui/slot/elements/SlotType.java new file mode 100644 index 000000000..73427fde1 --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/SlotType.java @@ -0,0 +1,45 @@ +package techreborn.client.gui.slot.elements; + +public enum SlotType { + NORMAL(1, 1, Sprite.SLOT_NORMAL, Sprite.BUTTON_SLOT_NORMAL, Sprite.BUTTON_HOVER_OVERLAY_SLOT_NORMAL); + + int slotOffsetX; + int slotOffsetY; + Sprite sprite; + Sprite buttonSprite; + Sprite buttonHoverOverlay; + + SlotType(int slotOffsetX, int slotOffsetY, Sprite sprite, Sprite buttonSprite, Sprite buttonHoverOverlay) { + this.slotOffsetX = slotOffsetX; + this.slotOffsetY = slotOffsetY; + this.sprite = sprite; + this.buttonSprite = buttonSprite; + this.buttonHoverOverlay = buttonHoverOverlay; + } + + SlotType(int slotOffset, Sprite sprite) { + this.slotOffsetX = slotOffset; + this.slotOffsetY = slotOffset; + this.sprite = sprite; + } + + public int getSlotOffsetX() { + return slotOffsetX; + } + + public int getSlotOffsetY() { + return slotOffsetY; + } + + public Sprite getSprite() { + return sprite; + } + + public Sprite getButtonSprite() { + return buttonSprite; + } + + public Sprite getButtonHoverOverlay() { + return buttonHoverOverlay; + } +} \ No newline at end of file diff --git a/src/main/java/techreborn/client/gui/slot/elements/Sprite.java b/src/main/java/techreborn/client/gui/slot/elements/Sprite.java new file mode 100644 index 000000000..8798c680d --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/Sprite.java @@ -0,0 +1,145 @@ +package techreborn.client.gui.slot.elements; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; +import reborncore.common.tile.TileLegacyMachineBase; + +public class Sprite implements ISprite { + public static final Sprite EMPTY = new Sprite(ElementBase.MECH_ELEMENTS, 0, 0, 0, 0); + public static final Sprite SLOT_NORMAL = new Sprite(ElementBase.MECH_ELEMENTS, 0, 0, 18, 18); + public static final Sprite CHARGE_SLOT_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 18, 0, 18, 18); + public static final Sprite DISCHARGE_SLOT_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 36, 0, 18, 18); + public static final Sprite ENERGY_BAR = new Sprite(ElementBase.MECH_ELEMENTS, 0, 18, 12, 40); + public static final Sprite ENERGY_BAR_BACKGROUND = new Sprite(ElementBase.MECH_ELEMENTS, 12, 18, 14, 42); + public static final Sprite TOP_ENERGY_BAR = new Sprite(ElementBase.MECH_ELEMENTS, 0, 215, 167, 2); + public static final Sprite TOP_ENERGY_BAR_BACKGROUND = new Sprite(ElementBase.MECH_ELEMENTS, 0, 217, 169, 3); + public static final Sprite LEFT_TAB = new Sprite(ElementBase.MECH_ELEMENTS, 0, 86, 23, 26); + public static final Sprite LEFT_TAB_SELECTED = new Sprite(ElementBase.MECH_ELEMENTS, 0, 60, 29, 26); + public static final Sprite CONFIGURE_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 26, 18, 16, 16); + public static final Sprite REDSTONE_DISABLED_ICON = new Sprite(new ItemStack(Items.GUNPOWDER)); + public static final Sprite REDSTONE_LOW_ICON = new Sprite(new ItemStack(Items.REDSTONE)); + public static final Sprite REDSTONE_HIGH_ICON = new Sprite(new ItemStack(Blocks.REDSTONE_TORCH)); + public static final Sprite UPGRADE_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 26, 34, 16, 16); + public static final Sprite ENERGY_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 46, 19, 9, 13); + public static final Sprite ENERGY_ICON_EMPTY = new Sprite(ElementBase.MECH_ELEMENTS, 62, 19, 9, 13); + public static final Sprite JEI_ICON = new Sprite(ElementBase.MECH_ELEMENTS, 42, 34, 16, 16); + public static final Sprite BUTTON_SLOT_NORMAL = new Sprite(ElementBase.MECH_ELEMENTS, 54, 0, 18, 18); + public static final Sprite FAKE_SLOT = new Sprite(ElementBase.MECH_ELEMENTS, 72, 0, 18, 18); + public static final Sprite BUTTON_HOVER_OVERLAY_SLOT_NORMAL = new Sprite(ElementBase.MECH_ELEMENTS, 90, 0, 18, 18); + public static final Sprite SLOT_CONFIG_POPUP = new Sprite(ElementBase.MECH_ELEMENTS, 29, 60, 62, 62); + public static final Sprite.Button EXIT_BUTTON = new Sprite.Button(new Sprite(ElementBase.MECH_ELEMENTS, 26, 122, 13, 13), new Sprite(ElementBase.MECH_ELEMENTS, 39, 122, 13, 13)); + public static final Sprite.CheckBox DARK_CHECK_BOX = new Sprite.CheckBox(new Sprite(ElementBase.MECH_ELEMENTS, 74, 18, 13, 13), new Sprite(ElementBase.MECH_ELEMENTS, 87, 18, 16, 13)); + public static final Sprite.CheckBox LIGHT_CHECK_BOX = new Sprite.CheckBox(new Sprite(ElementBase.MECH_ELEMENTS, 74, 31, 13, 13), new Sprite(ElementBase.MECH_ELEMENTS, 87, 31, 16, 13)); + + public final ResourceLocation textureLocation; + public final int x; + public final int y; + public final int width; + public final int height; + public int offsetX = 0; + public int offsetY = 0; + public ItemStack itemStack; + + public Sprite(ResourceLocation textureLocation, int x, int y, int width, int height) { + this.textureLocation = textureLocation; + this.x = x; + this.y = y; + this.width = width; + this.height = height; + this.itemStack = null; + } + + public Sprite(ItemStack stack) { + this.textureLocation = null; + this.x = -1; + this.y = -1; + this.width = -1; + this.height = -1; + this.itemStack = stack; + } + + public boolean hasStack() { + return itemStack != null; + } + + public boolean hasTextureInfo() { + return x >= 0 && y >= 0 && width >= 0 && height >= 0; + } + + public Sprite setOffsetX(int offsetX) { + this.offsetX = offsetX; + return this; + } + + public Sprite setOffsetY(int offsetY) { + this.offsetY = offsetY; + return this; + } + + @Override + public Sprite getSprite(TileLegacyMachineBase provider) { + return this; + } + + public static class Button { + private Sprite normal; + private Sprite hovered; + + public Button(Sprite normal, Sprite hovered) { + this.normal = normal; + this.hovered = hovered; + } + + public Sprite getNormal() { + return normal; + } + + public Sprite getHovered() { + return hovered; + } + } + + public static class ToggleButton { + private Sprite normal; + private Sprite hovered; + private Sprite pressed; + + public ToggleButton(Sprite normal, Sprite hovered, Sprite pressed) { + this.normal = normal; + this.hovered = hovered; + this.pressed = pressed; + } + + public Sprite getNormal() { + return normal; + } + + public Sprite getHovered() { + return hovered; + } + + public Sprite getPressed() { + return pressed; + } + } + + public static class CheckBox { + private Sprite normal; + private Sprite ticked; + + public CheckBox(Sprite normal, Sprite ticked) { + this.normal = normal; + this.ticked = ticked; + } + + public Sprite getNormal() { + return normal; + } + + public Sprite getTicked() { + return ticked; + } + } +} diff --git a/src/main/java/techreborn/client/gui/slot/elements/SpriteContainer.java b/src/main/java/techreborn/client/gui/slot/elements/SpriteContainer.java new file mode 100644 index 000000000..e7ec65c6f --- /dev/null +++ b/src/main/java/techreborn/client/gui/slot/elements/SpriteContainer.java @@ -0,0 +1,54 @@ +package techreborn.client.gui.slot.elements; + +import java.util.ArrayList; +import java.util.List; + +public class SpriteContainer { + public List offsetSprites = new ArrayList<>(); + + public SpriteContainer setSprite(int index, OffsetSprite sprite) { + offsetSprites.set(index, sprite); + return this; + } + + public SpriteContainer setSprite(int index, ISprite sprite, int offsetX, int offsetY) { + if (sprite instanceof Sprite) { + offsetSprites.set(index, new OffsetSprite(sprite).setOffsetX(((Sprite) sprite).offsetX + offsetX).setOffsetY(((Sprite) sprite).offsetY + offsetY)); + } else { + offsetSprites.set(index, new OffsetSprite(sprite, offsetX, offsetY)); + } + return this; + } + + public SpriteContainer setSprite(int index, ISprite sprite) { + if (sprite instanceof Sprite) { + offsetSprites.set(index, new OffsetSprite(sprite).setOffsetX(((Sprite) sprite).offsetX).setOffsetY(((Sprite) sprite).offsetY)); + } else { + offsetSprites.add(index, new OffsetSprite(sprite)); + } + return this; + } + + public SpriteContainer addSprite(OffsetSprite sprite) { + offsetSprites.add(sprite); + return this; + } + + public SpriteContainer addSprite(ISprite sprite, int offsetX, int offsetY) { + if (sprite instanceof Sprite) { + offsetSprites.add(new OffsetSprite(sprite).setOffsetX(((Sprite) sprite).offsetX + offsetX).setOffsetY(((Sprite) sprite).offsetY + offsetY)); + } else { + offsetSprites.add(new OffsetSprite(sprite, offsetX, offsetY)); + } + return this; + } + + public SpriteContainer addSprite(ISprite sprite) { + if (sprite instanceof Sprite) { + offsetSprites.add(new OffsetSprite(sprite).setOffsetX(((Sprite) sprite).offsetX).setOffsetY(((Sprite) sprite).offsetY)); + } else { + offsetSprites.add(new OffsetSprite(sprite)); + } + return this; + } +} diff --git a/src/main/java/techreborn/init/ModBlocks.java b/src/main/java/techreborn/init/ModBlocks.java index e3eabae82..0fc7a4dea 100644 --- a/src/main/java/techreborn/init/ModBlocks.java +++ b/src/main/java/techreborn/init/ModBlocks.java @@ -32,7 +32,7 @@ import net.minecraft.util.ResourceLocation; import net.minecraftforge.fml.common.registry.GameRegistry; import net.minecraftforge.oredict.OreDictionary; import reborncore.RebornRegistry; -import reborncore.common.tile.TileMachineBase; +import reborncore.common.tile.TileLegacyMachineBase; import reborncore.common.util.OreUtil; import reborncore.common.util.StringUtils; import techreborn.Core; @@ -349,7 +349,7 @@ public class ModBlocks { registerBlock(WIND_MILL, "wind_mill"); GameRegistry.registerTileEntity(TileWindMill.class, "TileWindMillTR"); - GameRegistry.registerTileEntity(TileMachineBase.class, "TileMachineBaseTR"); + GameRegistry.registerTileEntity(TileLegacyMachineBase.class, "TileMachineBaseTR"); RUBBER_LOG = new BlockRubberLog(); registerBlock(RUBBER_LOG, "rubber_log"); diff --git a/src/main/java/techreborn/init/recipes/CraftingTableRecipes.java b/src/main/java/techreborn/init/recipes/CraftingTableRecipes.java index f46130362..edc3de8ea 100644 --- a/src/main/java/techreborn/init/recipes/CraftingTableRecipes.java +++ b/src/main/java/techreborn/init/recipes/CraftingTableRecipes.java @@ -40,11 +40,7 @@ import techreborn.config.ConfigTechReborn; import techreborn.init.IC2Duplicates; import techreborn.init.ModBlocks; import techreborn.init.ModItems; -import techreborn.items.DynamicCell; -import techreborn.items.ItemDustsSmall; -import techreborn.items.ItemNuggets; -import techreborn.items.ItemParts; -import techreborn.items.ItemUpgrades; +import techreborn.items.*; /** * Created by Prospector @@ -90,8 +86,6 @@ public class CraftingTableRecipes extends RecipeMethods { } //Upgrades - registerShaped(ItemUpgrades.getUpgradeByName("injection"), "CHC", "PSP", "PPP", 'S', "chestWood", 'C', "circuitBasic", 'P', "plateIron", 'H', getStack(Blocks.HOPPER)); - registerShaped(ItemUpgrades.getUpgradeByName("ejection"), "CSC", "PHP", "PPP", 'S', "chestWood", 'C', "circuitBasic", 'P', "plateIron", 'H', getStack(Blocks.HOPPER)); registerShaped(ItemUpgrades.getUpgradeByName("energy_storage"), "PPP", "WBW", "PCP", 'P', "plankWood", 'W', getStack(IC2Duplicates.CABLE_ICOPPER), 'C', "circuitBasic", 'B', "reBattery"); registerShaped(ItemUpgrades.getUpgradeByName("overclock"), "TTT", "WCW", 'T', getMaterial("coolant_simple", Type.PART), 'W', getStack(IC2Duplicates.CABLE_ICOPPER), 'C', "circuitBasic"); registerShaped(ItemUpgrades.getUpgradeByName("overclock", 2), " T ", "WCW", 'T', getMaterial("helium_coolant_triple", Type.PART), 'W', getStack(IC2Duplicates.CABLE_ICOPPER), 'C', "circuitBasic"); diff --git a/src/main/java/techreborn/items/ItemUpgrades.java b/src/main/java/techreborn/items/ItemUpgrades.java index c41764c88..3a1e56e84 100644 --- a/src/main/java/techreborn/items/ItemUpgrades.java +++ b/src/main/java/techreborn/items/ItemUpgrades.java @@ -29,7 +29,6 @@ import net.minecraft.client.util.ITooltipFlag; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Container; -import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; @@ -37,16 +36,10 @@ import net.minecraft.util.NonNullList; import net.minecraft.world.World; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; -import net.minecraftforge.items.CapabilityItemHandler; -import net.minecraftforge.items.IItemHandler; -import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IUpgrade; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.IUpgradeHandler; -import reborncore.common.recipes.RecipeCrafter; -import reborncore.common.tile.IMachineSlotProvider; import reborncore.common.tile.TileLegacyMachineBase; -import reborncore.common.util.InventoryHelper; import reborncore.common.util.ItemNBTHelper; import techreborn.Core; import techreborn.client.TechRebornCreativeTabMisc; @@ -62,7 +55,7 @@ import java.util.List; public class ItemUpgrades extends ItemTR implements IUpgrade { - public static final String[] types = new String[] { "overclock", "transformer", "energy_storage", "range", "ejection", "injection" }; + public static final String[] types = new String[] { "overclock", "transformer", "energy_storage", "range" }; public ItemUpgrades() { setUnlocalizedName("techreborn.upgrade"); @@ -131,68 +124,6 @@ public class ItemUpgrades extends ItemTR implements IUpgrade { handler.addSpeedMulti(0.25); handler.addPowerMulti(0.5); - } else if (stack.getItemDamage() == 4) { - EnumFacing dir = getFacing(stack); - TileEntity tileEntity = machineBase.getWorld().getTileEntity(machineBase.getPos().offset(dir)); - if (tileEntity instanceof IInventory) { - if (machineBase instanceof IRecipeCrafterProvider) { - RecipeCrafter crafter = ((IRecipeCrafterProvider) machineBase).getRecipeCrafter(); - for (Integer outSlot : crafter.outputSlots) { - ItemStack outputStack = crafter.inventory.getStackInSlot(outSlot); - if (!outputStack.isEmpty()) { - int amount = InventoryHelper.testInventoryInsertion((IInventory) tileEntity, outputStack, dir); - if (amount > 0) { - InventoryHelper.insertItemIntoInventory((IInventory) tileEntity, outputStack); - crafter.inventory.decrStackSize(outSlot, amount); - } - } - } - } else if (machineBase instanceof IMachineSlotProvider) { - IMachineSlotProvider slotProvider = (IMachineSlotProvider) machineBase; - for (Integer outSlot : slotProvider.getOuputSlots()) { - ItemStack outputStack = slotProvider.getMachineInv().getStackInSlot(outSlot); - if (!outputStack.isEmpty()) { - int amount = InventoryHelper.testInventoryInsertion((IInventory) tileEntity, outputStack, dir); - if (amount > 0) { - InventoryHelper.insertItemIntoInventory((IInventory) tileEntity, outputStack); - slotProvider.getMachineInv().decrStackSize(outSlot, amount); - } - } - } - } else { - IInventory inventory = machineBase; - for (int outSlot = 0; outSlot < inventory.getSizeInventory(); outSlot++) { - ItemStack outputStack = inventory.getStackInSlot(outSlot); - if (!outputStack.isEmpty()) { - int amount = InventoryHelper.testInventoryInsertion((IInventory) tileEntity, outputStack, dir); - if (amount > 0) { - InventoryHelper.insertItemIntoInventory((IInventory) tileEntity, outputStack); - inventory.decrStackSize(outSlot, amount); - } - } - } - } - } - } else if (stack.getItemDamage() == 5) { - if (machineBase.getWorld().getTotalWorldTime() % 10 != 0) { - return; - } - EnumFacing dir = getFacing(stack); - TileEntity tileEntity = machineBase.getWorld().getTileEntity(machineBase.getPos().offset(dir)); - if (tileEntity != null && tileEntity.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, dir.getOpposite())) { - IItemHandler itemHandler = tileEntity.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, dir.getOpposite()); - for (int i = 0; i < itemHandler.getSlots(); i++) { - ItemStack extractedStack = itemHandler.extractItem(i, 1, true); - int amount = InventoryHelper.testInventoryInsertion(machineBase, extractedStack, dir.getOpposite()); - if (amount > 0) { - extractedStack = itemHandler.extractItem(i, 1, false); - extractedStack.setCount(1); - InventoryHelper.insertItemIntoInventory(machineBase, extractedStack); - } - - } - } - } if (machineBase instanceof TilePowerAcceptor) { if (stack.getItemDamage() == 2) { diff --git a/src/main/java/techreborn/proxies/ClientProxy.java b/src/main/java/techreborn/proxies/ClientProxy.java index 66d673791..166a63b84 100644 --- a/src/main/java/techreborn/proxies/ClientProxy.java +++ b/src/main/java/techreborn/proxies/ClientProxy.java @@ -43,6 +43,7 @@ import reborncore.client.multiblock.MultiblockRenderEvent; import techreborn.blocks.BlockRubberLeaves; import techreborn.client.*; import techreborn.client.gui.GuiBase; +import techreborn.client.gui.slot.GuiSlotConfiguration; import techreborn.client.keybindings.KeyBindings; import techreborn.client.render.ModelDynamicCell; import techreborn.client.render.entitys.RenderNukePrimed; @@ -74,6 +75,7 @@ public class ClientProxy extends CommonProxy { super.init(event); MinecraftForge.EVENT_BUS.register(new StackToolTipEvent()); multiblockRenderEvent = new MultiblockRenderEvent(); + MinecraftForge.EVENT_BUS.register(GuiSlotConfiguration.class); MinecraftForge.EVENT_BUS.register(multiblockRenderEvent); // TODO FIX ME ClientRegistry.registerKeyBinding(KeyBindings.config); diff --git a/src/main/java/techreborn/tiles/TileAssemblingMachine.java b/src/main/java/techreborn/tiles/TileAssemblingMachine.java index c516e82c7..11368d12b 100644 --- a/src/main/java/techreborn/tiles/TileAssemblingMachine.java +++ b/src/main/java/techreborn/tiles/TileAssemblingMachine.java @@ -25,12 +25,11 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -45,7 +44,7 @@ import techreborn.lib.ModInfo; @RebornRegistry(modID = ModInfo.MOD_ID) public class TileAssemblingMachine extends TilePowerAcceptor - implements IToolDrop, ISidedInventory, IInventoryProvider, IRecipeCrafterProvider, IContainerProvider { + implements IToolDrop, IInventoryProvider, IRecipeCrafterProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "assembling_machine", key = "AssemblingMachineMaxInput", comment = "Assembling Machine Max Input (Value in EU)") public static int maxInput = 128; @@ -136,20 +135,6 @@ public class TileAssemblingMachine extends TilePowerAcceptor return this.crafter; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 0, 1, 2 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0 || index == 1; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 2; - } @SuppressWarnings("deprecation") @Override diff --git a/src/main/java/techreborn/tiles/TileAutoCraftingTable.java b/src/main/java/techreborn/tiles/TileAutoCraftingTable.java index 7692d08da..a3c1ef608 100644 --- a/src/main/java/techreborn/tiles/TileAutoCraftingTable.java +++ b/src/main/java/techreborn/tiles/TileAutoCraftingTable.java @@ -27,7 +27,6 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.Container; import net.minecraft.inventory.IInventory; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.inventory.InventoryCrafting; import net.minecraft.item.ItemStack; import net.minecraft.item.crafting.CraftingManager; @@ -55,7 +54,7 @@ import java.util.List; /** * Created by modmuss50 on 20/06/2017. */ -public class TileAutoCraftingTable extends TilePowerAcceptor implements IContainerProvider, IInventoryProvider, ISidedInventory { +public class TileAutoCraftingTable extends TilePowerAcceptor implements IContainerProvider, IInventoryProvider { ResourceLocation currentRecipe; @@ -440,26 +439,4 @@ public class TileAutoCraftingTable extends TilePowerAcceptor implements IContain } return super.isItemValidForSlot(index, stack); } - - @Override - public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction) { - if (index == 9) { - return false; - } - int bestSlot = findBestSlotForStack(getIRecipe(), itemStackIn); - if (bestSlot != -1) { - return index == bestSlot; - } - return false; - } - - @Override - public int[] getSlotsForFace(EnumFacing side) { - return new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; - } - - @Override - public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction) { - return index == 9 || index == 10; - } } diff --git a/src/main/java/techreborn/tiles/TileChargeOMat.java b/src/main/java/techreborn/tiles/TileChargeOMat.java index bd021a30b..47b71c836 100644 --- a/src/main/java/techreborn/tiles/TileChargeOMat.java +++ b/src/main/java/techreborn/tiles/TileChargeOMat.java @@ -25,12 +25,11 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; @@ -43,7 +42,7 @@ import techreborn.lib.ModInfo; @RebornRegistry(modID = ModInfo.MOD_ID) public class TileChargeOMat extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, ISidedInventory, IContainerProvider { + implements IToolDrop, IInventoryProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "charge_bench", key = "ChargeBenchMaxInput", comment = "Charge Bench Max Input (Value in EU)") public static int maxInput = 512; @@ -87,28 +86,6 @@ public class TileChargeOMat extends TilePowerAcceptor return false; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2, 3, 4, 5 } : new int[] { 0, 1, 2, 3, 4, 5 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - // if (itemStack.getItem() instanceof IElectricItem) { - // double CurrentCharge = ElectricItem.manager.getCharge(itemStack); - // double MaxCharge = ((IElectricItem) - // itemStack.getItem()).getMaxCharge(itemStack); - // if (CurrentCharge == MaxCharge) - // return true; - // } - return false; - } @Override public double getBaseMaxPower() { diff --git a/src/main/java/techreborn/tiles/TileChemicalReactor.java b/src/main/java/techreborn/tiles/TileChemicalReactor.java index 7009b6c75..449e41add 100644 --- a/src/main/java/techreborn/tiles/TileChemicalReactor.java +++ b/src/main/java/techreborn/tiles/TileChemicalReactor.java @@ -25,13 +25,12 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.impl.ConfigRegistry; @@ -43,7 +42,7 @@ import techreborn.client.container.builder.ContainerBuilder; import techreborn.init.ModBlocks; public class TileChemicalReactor extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, ISidedInventory, IRecipeCrafterProvider, IContainerProvider { + implements IToolDrop, IInventoryProvider, IRecipeCrafterProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "chemical_reactor", key = "ChemicalReactorMaxInput", comment = "Chemical Reactor Max Input (Value in EU)") public static int maxInput = 128; @@ -97,33 +96,6 @@ public class TileChemicalReactor extends TilePowerAcceptor return tagCompound; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2 } : new int[] { 0, 1, 2 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex == 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2; - } - - // @Override - // public void addWailaInfo(List info) - // { - // super.addWailaInfo(info); - // info.add("Power Stored " + energy.getEnergyStored() +" EU"); - // if(crafter.currentRecipe !=null){ - // info.add("Power Usage " + crafter.currentRecipe.euPerTick() + " EU/t"); - // } - // } public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0 && this.crafter.currentNeededTicks > 0) { diff --git a/src/main/java/techreborn/tiles/TileChunkLoader.java b/src/main/java/techreborn/tiles/TileChunkLoader.java index bc24df016..d84fb31e0 100644 --- a/src/main/java/techreborn/tiles/TileChunkLoader.java +++ b/src/main/java/techreborn/tiles/TileChunkLoader.java @@ -27,8 +27,8 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; diff --git a/src/main/java/techreborn/tiles/TileIndustrialCentrifuge.java b/src/main/java/techreborn/tiles/TileIndustrialCentrifuge.java index 592a3be61..beccef5d9 100644 --- a/src/main/java/techreborn/tiles/TileIndustrialCentrifuge.java +++ b/src/main/java/techreborn/tiles/TileIndustrialCentrifuge.java @@ -29,9 +29,9 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import reborncore.api.IListInfoProvider; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -42,7 +42,6 @@ import techreborn.client.container.IContainerProvider; import techreborn.client.container.builder.BuiltContainer; import techreborn.client.container.builder.ContainerBuilder; import techreborn.init.ModBlocks; -import techreborn.items.DynamicCell; import techreborn.lib.ModInfo; import java.util.List; @@ -105,23 +104,6 @@ public class TileIndustrialCentrifuge extends TilePowerAcceptor return tagCompound; } - // ISidedInventory - - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2, 3, 4, 5 } : new int[] { 0, 1, 2, 3, 4, 5 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return itemStackIn.isItemEqual(DynamicCell.getEmptyCell(1).copy()) ? index == 1 : index == 0; - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex >= 2 && slotIndex <= 5; - } - @Override public void addInfo(final List info, final boolean isRealTile) { super.addInfo(info, isRealTile); diff --git a/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java b/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java index ad2bf58f8..ed13d517f 100644 --- a/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java +++ b/src/main/java/techreborn/tiles/TileIndustrialElectrolyzer.java @@ -25,13 +25,12 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -48,7 +47,7 @@ import techreborn.lib.ModInfo; @RebornRegistry(modID = ModInfo.MOD_ID) public class TileIndustrialElectrolyzer extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, ISidedInventory, IRecipeCrafterProvider, IContainerProvider { + implements IToolDrop, IInventoryProvider, IRecipeCrafterProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "industrial_electrolyzer", key = "IndustrialElectrolyzerMaxInput", comment = "Industrial Electrolyzer Max Input (Value in EU)") public static int maxInput = 128; @@ -115,26 +114,6 @@ public class TileIndustrialElectrolyzer extends TilePowerAcceptor // } // } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2, 3, 4, 5 } : new int[] { 0, 1, 2, 3, 4, 5 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack stack, final EnumFacing side) { - if (slotIndex > 1) - return false; - if (slotIndex == 1) - return ItemUtils.isItemEqual(stack, DynamicCell.getEmptyCell(1), true, true); - return !ItemUtils.isItemEqual(stack, DynamicCell.getEmptyCell(1), true, true); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2 || slotIndex == 3 || slotIndex == 4 || slotIndex == 5; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/TileIronAlloyFurnace.java b/src/main/java/techreborn/tiles/TileIronAlloyFurnace.java index 777ea73be..77ed6c718 100644 --- a/src/main/java/techreborn/tiles/TileIronAlloyFurnace.java +++ b/src/main/java/techreborn/tiles/TileIronAlloyFurnace.java @@ -312,20 +312,6 @@ public class TileIronAlloyFurnace extends TileLegacyMachineBase return this.inventory; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 0, 1, 2 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0 || index == 1; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 2; - } public int getBurnTime() { return this.burnTime; diff --git a/src/main/java/techreborn/tiles/TileIronFurnace.java b/src/main/java/techreborn/tiles/TileIronFurnace.java index 2b9d3be14..721c57268 100644 --- a/src/main/java/techreborn/tiles/TileIronFurnace.java +++ b/src/main/java/techreborn/tiles/TileIronFurnace.java @@ -26,11 +26,9 @@ package techreborn.tiles; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.item.crafting.FurnaceRecipes; import net.minecraft.tileentity.TileEntityFurnace; -import net.minecraft.util.EnumFacing; import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.tile.TileLegacyMachineBase; @@ -41,7 +39,7 @@ import techreborn.client.container.builder.BuiltContainer; import techreborn.client.container.builder.ContainerBuilder; public class TileIronFurnace extends TileLegacyMachineBase - implements IInventoryProvider, ISidedInventory, IContainerProvider { + implements IInventoryProvider, IContainerProvider { private static final int[] SLOTS_TOP = new int[] { 0, 2 }; private static final int[] SLOTS_BOTTOM = new int[] { 1 }; @@ -174,11 +172,6 @@ public class TileIronFurnace extends TileLegacyMachineBase return this.inventory; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? TileIronFurnace.SLOTS_BOTTOM : side == EnumFacing.UP ? TileIronFurnace.SLOTS_TOP : TileIronFurnace.SLOTS_SIDES; - } - @Override public boolean isItemValidForSlot(int index, ItemStack stack) { boolean isFuel = TileEntityFurnace.isItemFuel(stack); @@ -191,23 +184,6 @@ public class TileIronFurnace extends TileLegacyMachineBase return index != output; } - @Override - public boolean canInsertItem(int index, ItemStack stack, EnumFacing direction) { - boolean isFuel = TileEntityFurnace.isItemFuel(stack); - if(isFuel){ - ItemStack fuelSlotStack = getStackInSlot(fuelslot); - if(fuelSlotStack.isEmpty() || ItemUtils.isItemEqual(stack, fuelSlotStack, true, true) && fuelSlotStack.getMaxStackSize() != fuelSlotStack.getCount()){ - return index == fuelslot; - } - } - return index != output; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return true; - } - public int getBurnTime() { return this.fuel; } diff --git a/src/main/java/techreborn/tiles/TileMatterFabricator.java b/src/main/java/techreborn/tiles/TileMatterFabricator.java index 6ee7f0742..06bc3701c 100644 --- a/src/main/java/techreborn/tiles/TileMatterFabricator.java +++ b/src/main/java/techreborn/tiles/TileMatterFabricator.java @@ -27,8 +27,8 @@ package techreborn.tiles; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; @@ -75,23 +75,6 @@ public class TileMatterFabricator extends TilePowerAcceptor return false; } - @Override - public int[] getSlotsForFace(EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2, 3, 4, 5, 6 } : new int[] { 0, 1, 2, 3, 4, 5, 6 }; - } - - @Override - public boolean canInsertItem(int slotIndex, ItemStack itemStack, EnumFacing side) { - if (slotIndex >= 6) - return false; - return isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(int slotIndex, ItemStack itemStack, EnumFacing side) { - return slotIndex >= 6 && slotIndex <= 10; - } - @Override public void update() { if (world.isRemote){ return; } diff --git a/src/main/java/techreborn/tiles/TileQuantumTank.java b/src/main/java/techreborn/tiles/TileQuantumTank.java index 01ed0102c..1e8148a0d 100644 --- a/src/main/java/techreborn/tiles/TileQuantumTank.java +++ b/src/main/java/techreborn/tiles/TileQuantumTank.java @@ -33,8 +33,8 @@ import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; import reborncore.api.IListInfoProvider; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; import reborncore.common.tile.TileLegacyMachineBase; diff --git a/src/main/java/techreborn/tiles/TileRollingMachine.java b/src/main/java/techreborn/tiles/TileRollingMachine.java index 9f4eeee8b..9305c4f27 100644 --- a/src/main/java/techreborn/tiles/TileRollingMachine.java +++ b/src/main/java/techreborn/tiles/TileRollingMachine.java @@ -30,8 +30,8 @@ import net.minecraft.inventory.InventoryCrafting; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; @@ -192,23 +192,6 @@ public class TileRollingMachine extends TilePowerAcceptor tagCompound.setInteger("tickTime", this.tickTime); } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.DOWN)) - return new int[] { 0 }; - return new int[0]; - } - - @Override - public boolean canInsertItem(final int Index, final ItemStack itemStack, final EnumFacing side) { - return false; - } - - @Override - public boolean canExtractItem(final int Index, final ItemStack itemStack, final EnumFacing side) { - return Index == outputSlot; - } - @Override public void invalidate() { super.invalidate(); diff --git a/src/main/java/techreborn/tiles/TileScrapboxinator.java b/src/main/java/techreborn/tiles/TileScrapboxinator.java index ae56275bf..595bbbc08 100644 --- a/src/main/java/techreborn/tiles/TileScrapboxinator.java +++ b/src/main/java/techreborn/tiles/TileScrapboxinator.java @@ -26,11 +26,10 @@ package techreborn.tiles; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; @@ -46,7 +45,7 @@ import techreborn.lib.ModInfo; @RebornRegistry(modID = ModInfo.MOD_ID) public class TileScrapboxinator extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, ISidedInventory, IContainerProvider { + implements IToolDrop, IInventoryProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "scrapboxinator", key = "ScrapboxinatorMaxInput", comment = "Scrapboxinator Max Input (Value in EU)") public static int maxInput = 32; @@ -152,25 +151,6 @@ public class TileScrapboxinator extends TilePowerAcceptor return false; } - // ISidedInventory - - @Override - public int[] getSlotsForFace(EnumFacing side) { - return new int[] { 0, 1}; - } - - @Override - public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction){ - if (index == 0) { - return true; - } - return false; - } - - @Override - public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction){ - return index == 1; - } @Override public double getBaseMaxPower() { return maxEnergy; diff --git a/src/main/java/techreborn/tiles/cable/TileCable.java b/src/main/java/techreborn/tiles/cable/TileCable.java index 23529ee5a..1e097213b 100644 --- a/src/main/java/techreborn/tiles/cable/TileCable.java +++ b/src/main/java/techreborn/tiles/cable/TileCable.java @@ -24,9 +24,6 @@ package techreborn.tiles.cable; -import java.util.ArrayList; -import java.util.List; - import net.minecraft.nbt.NBTTagCompound; import net.minecraft.network.NetworkManager; import net.minecraft.network.play.server.SPacketUpdateTileEntity; @@ -45,6 +42,9 @@ import reborncore.common.util.StringUtils; import techreborn.blocks.cable.BlockCable; import techreborn.blocks.cable.EnumCableType; +import java.util.ArrayList; +import java.util.List; + /** * Created by modmuss50 on 19/05/2017. */ diff --git a/src/main/java/techreborn/tiles/fusionReactor/TileFusionControlComputer.java b/src/main/java/techreborn/tiles/fusionReactor/TileFusionControlComputer.java index a18451784..5bf6fb3e3 100644 --- a/src/main/java/techreborn/tiles/fusionReactor/TileFusionControlComputer.java +++ b/src/main/java/techreborn/tiles/fusionReactor/TileFusionControlComputer.java @@ -311,31 +311,6 @@ public class TileFusionControlComputer extends TilePowerAcceptor implements IToo public ITextComponent getDisplayName() { return null; } - - @Override - public int[] getSlotsForFace(EnumFacing side) { - return new int[] { 0, 1, 2 }; - } - - /** - * Returns true if automation can insert the given item in the given slot from the given side. - */ - @Override - public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction){ - if (index == 0 || index == 1) { - return true; - } - return false; - } - - /** - * Returns true if automation can extract the given item in the given slot from the given side. - */ - @Override - public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction){ - return index == 2; - } - @Override public Inventory getInventory() { diff --git a/src/main/java/techreborn/tiles/generator/TileBaseFluidGenerator.java b/src/main/java/techreborn/tiles/generator/TileBaseFluidGenerator.java index 7737b8433..c264a09c2 100644 --- a/src/main/java/techreborn/tiles/generator/TileBaseFluidGenerator.java +++ b/src/main/java/techreborn/tiles/generator/TileBaseFluidGenerator.java @@ -31,8 +31,8 @@ import net.minecraft.util.EnumFacing; import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.util.FluidUtils; diff --git a/src/main/java/techreborn/tiles/generator/TileCreativeSolarPanel.java b/src/main/java/techreborn/tiles/generator/TileCreativeSolarPanel.java index 8613e4e32..4306e0f49 100644 --- a/src/main/java/techreborn/tiles/generator/TileCreativeSolarPanel.java +++ b/src/main/java/techreborn/tiles/generator/TileCreativeSolarPanel.java @@ -28,8 +28,8 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; import net.minecraftforge.fml.common.Optional; -import reborncore.api.power.EnumPowerTier; import reborncore.api.IToolDrop; +import reborncore.api.power.EnumPowerTier; import reborncore.common.powerSystem.TilePowerAcceptor; import techreborn.init.ModBlocks; diff --git a/src/main/java/techreborn/tiles/generator/TileDragonEggSyphon.java b/src/main/java/techreborn/tiles/generator/TileDragonEggSyphon.java index f43c33715..109f4c603 100644 --- a/src/main/java/techreborn/tiles/generator/TileDragonEggSyphon.java +++ b/src/main/java/techreborn/tiles/generator/TileDragonEggSyphon.java @@ -29,8 +29,8 @@ import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; diff --git a/src/main/java/techreborn/tiles/generator/TileSolidFuelGenerator.java b/src/main/java/techreborn/tiles/generator/TileSolidFuelGenerator.java index f18b3d8b2..6a5c078c6 100644 --- a/src/main/java/techreborn/tiles/generator/TileSolidFuelGenerator.java +++ b/src/main/java/techreborn/tiles/generator/TileSolidFuelGenerator.java @@ -31,8 +31,8 @@ import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntityFurnace; import net.minecraft.util.EnumFacing; import net.minecraftforge.common.ForgeModContainer; -import reborncore.api.tile.IInventoryProvider; import reborncore.api.IToolDrop; +import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; @@ -182,16 +182,6 @@ public class TileSolidFuelGenerator extends TilePowerAcceptor implements IToolDr .syncIntegerValue(this::getTotalBurnTime, this::setTotalBurnTime).addInventory().create(this); } - @Override - public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction) { - return TileSolidFuelGenerator.getItemBurnTime(itemStackIn) != 0; - } - - @Override - public int[] getSlotsForFace(EnumFacing side) { - return new int[] { fuelSlot }; - } - @Override public boolean canBeUpgraded() { return false; diff --git a/src/main/java/techreborn/tiles/multiblock/TileDistillationTower.java b/src/main/java/techreborn/tiles/multiblock/TileDistillationTower.java index 6a5054c38..8c030b970 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileDistillationTower.java +++ b/src/main/java/techreborn/tiles/multiblock/TileDistillationTower.java @@ -141,21 +141,6 @@ public class TileDistillationTower extends TilePowerAcceptor this.crafter.writeToNBT(tagCompound); return tagCompound; } - - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 0, 1, 2, 3, 4, 5 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0 || index == 1; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 2 || index == 3 || index == 4 || index == 5; - } // IToolDrop @Override diff --git a/src/main/java/techreborn/tiles/multiblock/TileImplosionCompressor.java b/src/main/java/techreborn/tiles/multiblock/TileImplosionCompressor.java index 4b82d9539..5bb263a39 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileImplosionCompressor.java +++ b/src/main/java/techreborn/tiles/multiblock/TileImplosionCompressor.java @@ -29,9 +29,9 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -104,21 +104,6 @@ public class TileImplosionCompressor extends TilePowerAcceptor return tagCompound; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 0, 1, 2, 3 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0 || index == 1; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 2 || index == 3; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/multiblock/TileIndustrialBlastFurnace.java b/src/main/java/techreborn/tiles/multiblock/TileIndustrialBlastFurnace.java index f83578c36..6ecf5bd15 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileIndustrialBlastFurnace.java +++ b/src/main/java/techreborn/tiles/multiblock/TileIndustrialBlastFurnace.java @@ -34,9 +34,9 @@ import net.minecraft.network.play.server.SPacketUpdateTileEntity; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.multiblock.IMultiblockPart; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; @@ -171,24 +171,6 @@ public class TileIndustrialBlastFurnace extends TilePowerAcceptor implements ITo return tagCompound; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2, 3 } : new int[] { 0, 1, 2, 3 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex >= 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2 || slotIndex == 3; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/multiblock/TileIndustrialGrinder.java b/src/main/java/techreborn/tiles/multiblock/TileIndustrialGrinder.java index 21ad6a93d..8aad77c8e 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileIndustrialGrinder.java +++ b/src/main/java/techreborn/tiles/multiblock/TileIndustrialGrinder.java @@ -37,9 +37,9 @@ import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidBlock; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -159,19 +159,6 @@ public class TileIndustrialGrinder extends TilePowerAcceptor implements IToolDro return super.getCapability(capability, facing); } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 1, 0, 2, 3, 4, 5, 6 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex >= 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - @Override public boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) { if (slotIndex == 1) { @@ -185,11 +172,6 @@ public class TileIndustrialGrinder extends TilePowerAcceptor implements IToolDro return true; } - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2 || slotIndex == 3 || slotIndex == 4 || slotIndex == 5 || slotIndex == 6; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/multiblock/TileIndustrialSawmill.java b/src/main/java/techreborn/tiles/multiblock/TileIndustrialSawmill.java index 9df8c8db8..446558651 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileIndustrialSawmill.java +++ b/src/main/java/techreborn/tiles/multiblock/TileIndustrialSawmill.java @@ -37,9 +37,9 @@ import net.minecraftforge.common.capabilities.Capability; import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.IFluidBlock; import net.minecraftforge.fluids.capability.CapabilityFluidHandler; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -191,18 +191,6 @@ public class TileIndustrialSawmill extends TilePowerAcceptor implements IToolDro return maxInput; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 1, 0, 2, 3, 4, 5 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing direction) { - if (slotIndex >= 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - @Override public boolean isItemValidForSlot(int slotIndex, ItemStack itemStack) { if (slotIndex == 1) { @@ -215,11 +203,6 @@ public class TileIndustrialSawmill extends TilePowerAcceptor implements IToolDro return true; } - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2 || slotIndex == 3 || slotIndex == 4 || slotIndex == 5; - } - // IToolDrop @Override public ItemStack getToolDrop(final EntityPlayer entityPlayer) { diff --git a/src/main/java/techreborn/tiles/multiblock/TileVacuumFreezer.java b/src/main/java/techreborn/tiles/multiblock/TileVacuumFreezer.java index b34a4310b..24a649923 100644 --- a/src/main/java/techreborn/tiles/multiblock/TileVacuumFreezer.java +++ b/src/main/java/techreborn/tiles/multiblock/TileVacuumFreezer.java @@ -28,9 +28,9 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.util.Inventory; @@ -133,21 +133,6 @@ public class TileVacuumFreezer extends TilePowerAcceptor return this.crafter; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return new int[] { 0, 1 }; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 1; - } - @Override public BuiltContainer createContainer(final EntityPlayer player) { return new ContainerBuilder("vacuumfreezer").player(player.inventory).inventory().hotbar().addInventory() diff --git a/src/main/java/techreborn/tiles/storage/TileEnergyStorage.java b/src/main/java/techreborn/tiles/storage/TileEnergyStorage.java index 93cb5a631..0b9df4573 100644 --- a/src/main/java/techreborn/tiles/storage/TileEnergyStorage.java +++ b/src/main/java/techreborn/tiles/storage/TileEnergyStorage.java @@ -29,10 +29,10 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; import net.minecraft.util.ITickable; +import reborncore.api.IToolDrop; import reborncore.api.power.EnumPowerTier; import reborncore.api.power.IEnergyItemInfo; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.PoweredItem; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.util.Inventory; @@ -154,21 +154,6 @@ public class TileEnergyStorage extends TilePowerAcceptor implements IToolDrop, I return inventory; } - @Override - public int[] getSlotsForFace(EnumFacing side) { - return new int[] { 0, 1 }; - } - - @Override - public boolean canInsertItem(int index, ItemStack itemStackIn, EnumFacing direction) { - return true; - } - - @Override - public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction) { - return true; - } - @Override public boolean canBeUpgraded() { return false; diff --git a/src/main/java/techreborn/tiles/teir1/TileAlloySmelter.java b/src/main/java/techreborn/tiles/teir1/TileAlloySmelter.java index 755339b18..8d66fdd0d 100644 --- a/src/main/java/techreborn/tiles/teir1/TileAlloySmelter.java +++ b/src/main/java/techreborn/tiles/teir1/TileAlloySmelter.java @@ -25,14 +25,13 @@ package techreborn.tiles.teir1; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.recipe.RecipeHandler; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.registration.RebornRegistry; @@ -49,7 +48,7 @@ import techreborn.lib.ModInfo; @RebornRegistry(modID = ModInfo.MOD_ID) public class TileAlloySmelter extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, ISidedInventory, IRecipeCrafterProvider, IContainerProvider { + implements IToolDrop, IInventoryProvider, IRecipeCrafterProvider, IContainerProvider { @ConfigRegistry(config = "machines", category = "alloy_smelter", key = "AlloySmelterMaxInput", comment = "Alloy Smelter Max Input (Value in EU)") public static int maxInput = 32; @@ -102,24 +101,6 @@ public class TileAlloySmelter extends TilePowerAcceptor return tagCompound; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - return side == EnumFacing.DOWN ? new int[] { 0, 1, 2 } : new int[] { 0, 1, 2 }; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex == 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 2; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0 && this.crafter.currentNeededTicks != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/teir1/TileCompressor.java b/src/main/java/techreborn/tiles/teir1/TileCompressor.java index 040906132..831ab064a 100644 --- a/src/main/java/techreborn/tiles/teir1/TileCompressor.java +++ b/src/main/java/techreborn/tiles/teir1/TileCompressor.java @@ -27,9 +27,9 @@ package techreborn.tiles.teir1; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.util.Inventory; @@ -72,26 +72,6 @@ public class TileCompressor extends TilePowerAcceptor implements IToolDrop, IInv return false; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.UP)) - return new int[] { 0 }; - else if (side.equals(EnumFacing.DOWN)) - return new int[] { 1 }; - return new int[0]; - } - - @Override - public boolean canInsertItem(final int Index, final ItemStack itemStack, final EnumFacing side) { - return Index == 0; - } - - @Override - public boolean canExtractItem(final int Index, final ItemStack itemStack, final EnumFacing side) { - return Index == 1; - } - public int getProgressScaled(final int scale) { if (this.crafter.currentTickTime != 0) { return this.crafter.currentTickTime * scale / this.crafter.currentNeededTicks; diff --git a/src/main/java/techreborn/tiles/teir1/TileElectricFurnace.java b/src/main/java/techreborn/tiles/teir1/TileElectricFurnace.java index 76734c671..646f3d349 100644 --- a/src/main/java/techreborn/tiles/teir1/TileElectricFurnace.java +++ b/src/main/java/techreborn/tiles/teir1/TileElectricFurnace.java @@ -26,17 +26,13 @@ package techreborn.tiles.teir1; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.inventory.IInventory; -import net.minecraft.inventory.ISidedInventory; import net.minecraft.item.ItemStack; import net.minecraft.item.crafting.FurnaceRecipes; import net.minecraft.util.EnumFacing; -import org.apache.commons.lang3.ArrayUtils; import reborncore.api.IToolDrop; import reborncore.api.tile.IInventoryProvider; import reborncore.common.blocks.BlockMachineBase; import reborncore.common.powerSystem.TilePowerAcceptor; -import reborncore.common.tile.IMachineSlotProvider; import reborncore.common.util.Inventory; import techreborn.client.container.IContainerProvider; import techreborn.client.container.builder.BuiltContainer; @@ -44,7 +40,7 @@ import techreborn.client.container.builder.ContainerBuilder; import techreborn.init.ModBlocks; public class TileElectricFurnace extends TilePowerAcceptor - implements IToolDrop, IInventoryProvider, IContainerProvider, IMachineSlotProvider, ISidedInventory { + implements IToolDrop, IInventoryProvider, IContainerProvider { public Inventory inventory = new Inventory(3, "TileElectricFurnace", 64, this); public int capacity = 1000; @@ -167,31 +163,6 @@ public class TileElectricFurnace extends TilePowerAcceptor return false; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.UP)) - return new int[] { 0 }; - else if (side.equals(EnumFacing.DOWN)) - return new int[] { 1 }; - else if (ArrayUtils.contains(EnumFacing.HORIZONTALS, side)){ - return new int[]{0}; - } - return new int[0]; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex == 2) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 1; - } - @Override public double getBaseMaxPower() { return this.capacity; @@ -237,21 +208,6 @@ public class TileElectricFurnace extends TilePowerAcceptor .syncIntegerValue(this::getBurnTime, this::setBurnTime).addInventory().create(this); } - @Override - public int[] getInputSlots() { - return new int[] { input1 }; - } - - @Override - public int[] getOuputSlots() { - return new int[] { output }; - } - - @Override - public IInventory getMachineInv() { - return inventory; - } - @Override public boolean canBeUpgraded() { return true; diff --git a/src/main/java/techreborn/tiles/teir1/TileExtractor.java b/src/main/java/techreborn/tiles/teir1/TileExtractor.java index a0744f46d..69dd89079 100644 --- a/src/main/java/techreborn/tiles/teir1/TileExtractor.java +++ b/src/main/java/techreborn/tiles/teir1/TileExtractor.java @@ -28,9 +28,9 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.util.Inventory; @@ -130,25 +130,6 @@ public class TileExtractor extends TilePowerAcceptor return this.crafter; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.UP)) - return new int[] { 0 }; - else if (side.equals(EnumFacing.DOWN)) - return new int[] { 1 }; - return new int[0]; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 1; - } - @Override public BuiltContainer createContainer(final EntityPlayer player) { return new ContainerBuilder("extractor").player(player.inventory).inventory().hotbar().addInventory().tile(this) diff --git a/src/main/java/techreborn/tiles/teir1/TileGrinder.java b/src/main/java/techreborn/tiles/teir1/TileGrinder.java index c2c597e01..5e23e3c49 100644 --- a/src/main/java/techreborn/tiles/teir1/TileGrinder.java +++ b/src/main/java/techreborn/tiles/teir1/TileGrinder.java @@ -28,9 +28,9 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumFacing; +import reborncore.api.IToolDrop; import reborncore.api.recipe.IRecipeCrafterProvider; import reborncore.api.tile.IInventoryProvider; -import reborncore.api.IToolDrop; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.recipes.RecipeCrafter; import reborncore.common.util.Inventory; @@ -131,25 +131,6 @@ public class TileGrinder extends TilePowerAcceptor return this.crafter; } - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.UP)) - return new int[] { 0 }; - else if (side.equals(EnumFacing.DOWN)) - return new int[] { 1 }; - return new int[0]; - } - - @Override - public boolean canInsertItem(final int index, final ItemStack itemStackIn, final EnumFacing direction) { - return index == 0; - } - - @Override - public boolean canExtractItem(final int index, final ItemStack stack, final EnumFacing direction) { - return index == 1; - } - @Override public BuiltContainer createContainer(final EntityPlayer player) { return new ContainerBuilder("grinder").player(player.inventory).inventory().hotbar().addInventory().tile(this) diff --git a/src/main/java/techreborn/tiles/teir1/TileRecycler.java b/src/main/java/techreborn/tiles/teir1/TileRecycler.java index e80a74fb4..3ae572f69 100644 --- a/src/main/java/techreborn/tiles/teir1/TileRecycler.java +++ b/src/main/java/techreborn/tiles/teir1/TileRecycler.java @@ -138,28 +138,6 @@ public class TileRecycler extends TilePowerAcceptor implements IToolDrop, IInven return false; } - // ISidedInventory - @Override - public int[] getSlotsForFace(final EnumFacing side) { - if (side.equals(EnumFacing.UP)) - return new int[] { 0 }; - else if (side.equals(EnumFacing.DOWN)) - return new int[] { 1 }; - return new int[0]; - } - - @Override - public boolean canInsertItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - if (slotIndex == 1) - return false; - return this.isItemValidForSlot(slotIndex, itemStack); - } - - @Override - public boolean canExtractItem(final int slotIndex, final ItemStack itemStack, final EnumFacing side) { - return slotIndex == 1; - } - @Override public double getBaseMaxPower() { return this.capacity; diff --git a/src/main/java/techreborn/tiles/transformers/TileTransformer.java b/src/main/java/techreborn/tiles/transformers/TileTransformer.java index 1269af948..eb84a7ae8 100644 --- a/src/main/java/techreborn/tiles/transformers/TileTransformer.java +++ b/src/main/java/techreborn/tiles/transformers/TileTransformer.java @@ -31,8 +31,8 @@ import net.minecraft.util.EnumFacing; import net.minecraft.util.ITickable; import net.minecraft.util.text.TextFormatting; import reborncore.api.IListInfoProvider; -import reborncore.api.power.EnumPowerTier; import reborncore.api.IToolDrop; +import reborncore.api.power.EnumPowerTier; import reborncore.common.powerSystem.TilePowerAcceptor; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; diff --git a/src/main/resources/assets/techreborn/textures/gui/elements.png b/src/main/resources/assets/techreborn/textures/gui/elements.png new file mode 100644 index 0000000000000000000000000000000000000000..7221aaddd62eb4dcfbe1a067deeb0cd0deed1d3d GIT binary patch literal 12076 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/techreborn/textures/gui/gui_sheet.png b/src/main/resources/assets/techreborn/textures/gui/gui_sheet.png index 3e6b8473f17bf34a76ce2be321a0ae9c518d59a9..8d1f243c9ced9f8b2be5e81a9a5fe4f40048c869 100644 GIT binary patch literal 15319 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 U7q%My2Qy&z&V4&Fx6{J@5BJIfhyVZp