diff --git a/assets/hbm/textures/gui/gui_chemplant.png b/assets/hbm/textures/gui/gui_chemplant.png new file mode 100644 index 000000000..27443832a Binary files /dev/null and b/assets/hbm/textures/gui/gui_chemplant.png differ diff --git a/assets/hbm/textures/items/chemistry_template.png b/assets/hbm/textures/items/chemistry_template.png new file mode 100644 index 000000000..eb008e07e Binary files /dev/null and b/assets/hbm/textures/items/chemistry_template.png differ diff --git a/com/hbm/blocks/machine/MachineChemplant.java b/com/hbm/blocks/machine/MachineChemplant.java index cd15e2c7a..1000b48a1 100644 --- a/com/hbm/blocks/machine/MachineChemplant.java +++ b/com/hbm/blocks/machine/MachineChemplant.java @@ -54,8 +54,8 @@ public class MachineChemplant extends BlockContainer implements IMultiblock { if (i == 0) { world.setBlockMetadataWithNotify(x, y, z, 5, 2); - if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.assemblerDimensionEast)) { - MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.assemblerDimensionEast, ModBlocks.dummy_block_chemplant); + if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.chemplantDimensionEast)) { + MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.chemplantDimensionEast, ModBlocks.dummy_block_chemplant); // DummyBlockChemplant.safeBreak = true; @@ -99,8 +99,8 @@ public class MachineChemplant extends BlockContainer implements IMultiblock { } if (i == 1) { world.setBlockMetadataWithNotify(x, y, z, 3, 2); - if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.assemblerDimensionSouth)) { - MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.assemblerDimensionSouth, ModBlocks.dummy_block_chemplant); + if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.chemplantDimensionSouth)) { + MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.chemplantDimensionSouth, ModBlocks.dummy_block_chemplant); // DummyBlockChemplant.safeBreak = true; @@ -144,8 +144,8 @@ public class MachineChemplant extends BlockContainer implements IMultiblock { } if (i == 2) { world.setBlockMetadataWithNotify(x, y, z, 4, 2); - if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.assemblerDimensionWest)) { - MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.assemblerDimensionWest, ModBlocks.dummy_block_chemplant); + if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.chemplantDimensionWest)) { + MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.chemplantDimensionWest, ModBlocks.dummy_block_chemplant); // DummyBlockChemplant.safeBreak = true; @@ -189,8 +189,8 @@ public class MachineChemplant extends BlockContainer implements IMultiblock { } if (i == 3) { world.setBlockMetadataWithNotify(x, y, z, 2, 2); - if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.assemblerDimensionNorth)) { - MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.assemblerDimensionNorth, ModBlocks.dummy_block_chemplant); + if(MultiblockHandler.checkSpace(world, x, y, z, MultiblockHandler.chemplantDimensionNorth)) { + MultiblockHandler.fillUp(world, x, y, z, MultiblockHandler.chemplantDimensionNorth, ModBlocks.dummy_block_chemplant); // DummyBlockChemplant.safeBreak = true; diff --git a/com/hbm/handler/GUIHandler.java b/com/hbm/handler/GUIHandler.java index b9721904a..b45c334f2 100644 --- a/com/hbm/handler/GUIHandler.java +++ b/com/hbm/handler/GUIHandler.java @@ -17,6 +17,7 @@ import com.hbm.inventory.container.ContainerLaunchPadTier1; import com.hbm.inventory.container.ContainerMachineAssembler; import com.hbm.inventory.container.ContainerMachineBattery; import com.hbm.inventory.container.ContainerMachineCMBFactory; +import com.hbm.inventory.container.ContainerMachineChemplant; import com.hbm.inventory.container.ContainerMachineCoal; import com.hbm.inventory.container.ContainerMachineCyclotron; import com.hbm.inventory.container.ContainerMachineDeuterium; @@ -59,6 +60,7 @@ import com.hbm.inventory.gui.GUIMachineAssembler; import com.hbm.inventory.gui.GUIMachineBattery; import com.hbm.inventory.gui.GUIMachineCMBFactory; import com.hbm.inventory.gui.GUIMachineCentrifuge; +import com.hbm.inventory.gui.GUIMachineChemplant; import com.hbm.inventory.gui.GUIMachineCoal; import com.hbm.inventory.gui.GUIMachineCyclotron; import com.hbm.inventory.gui.GUIMachineDeuterium; @@ -107,6 +109,7 @@ import com.hbm.tileentity.TileEntityMachineAssembler; import com.hbm.tileentity.TileEntityMachineBattery; import com.hbm.tileentity.TileEntityMachineCMBFactory; import com.hbm.tileentity.TileEntityMachineCentrifuge; +import com.hbm.tileentity.TileEntityMachineChemplant; import com.hbm.tileentity.TileEntityMachineCoal; import com.hbm.tileentity.TileEntityMachineCyclotron; import com.hbm.tileentity.TileEntityMachineDeuterium; @@ -510,6 +513,14 @@ public class GUIHandler implements IGuiHandler { return new ContainerMachineAssembler(player.inventory, (TileEntityMachineAssembler) entity); } } + + case ModBlocks.guiID_machine_chemplant: + { + if(entity instanceof TileEntityMachineChemplant) + { + return new ContainerMachineChemplant(player.inventory, (TileEntityMachineChemplant) entity); + } + } } return null; } @@ -882,6 +893,14 @@ public class GUIHandler implements IGuiHandler { return new GUIMachineAssembler(player.inventory, (TileEntityMachineAssembler) entity); } } + + case ModBlocks.guiID_machine_chemplant: + { + if(entity instanceof TileEntityMachineChemplant) + { + return new GUIMachineChemplant(player.inventory, (TileEntityMachineChemplant) entity); + } + } } } return null; diff --git a/com/hbm/handler/MultiblockHandler.java b/com/hbm/handler/MultiblockHandler.java index 172be0fed..8c25b44e8 100644 --- a/com/hbm/handler/MultiblockHandler.java +++ b/com/hbm/handler/MultiblockHandler.java @@ -38,6 +38,7 @@ public class MultiblockHandler { } //Approved! + //pos x, neg x, pos y, neg y, pos z, neg z public static final int[] iGenDimensionNorth = new int[] { 1, 1, 2, 0, 3, 2 }; public static final int[] iGenDimensionEast = new int[] { 2, 3, 2, 0, 1, 1 }; public static final int[] iGenDimensionSouth = new int[] { 1, 1, 2, 0, 2, 3 }; @@ -47,10 +48,14 @@ public class MultiblockHandler { public static final int[] wellDimension = new int[] { 1, 1, 5, 0, 1, 1 }; public static final int[] flareDimension = new int[] { 1, 1, 9, 0, 1, 1 }; public static final int[] drillDimension = new int[] { 1, 1, 3, 0, 1, 1 }; - public static final int[] assemblerDimensionNorth = new int[] { 2, 1, 1, 0, 1, 2 }; - public static final int[] assemblerDimensionEast = new int[] { 2, 1, 1, 0, 2, 1 }; - public static final int[] assemblerDimensionSouth = new int[] { 1, 2, 1, 0, 2, 1 }; - public static final int[] assemblerDimensionWest = new int[] { 1, 2, 1, 0, 1, 2 }; + public static final int[] assemblerDimensionNorth = new int[] { 2, 1, 2, 0, 1, 2 }; + public static final int[] assemblerDimensionEast = new int[] { 2, 1, 2, 0, 2, 1 }; + public static final int[] assemblerDimensionSouth = new int[] { 1, 2, 2, 0, 2, 1 }; + public static final int[] assemblerDimensionWest = new int[] { 1, 2, 2, 0, 1, 2 }; + public static final int[] chemplantDimensionNorth = new int[] { 2, 1, 2, 0, 1, 2 }; + public static final int[] chemplantDimensionEast = new int[] { 2, 1, 2, 0, 2, 1 }; + public static final int[] chemplantDimensionSouth = new int[] { 1, 2, 2, 0, 2, 1 }; + public static final int[] chemplantDimensionWest = new int[] { 1, 2, 2, 0, 1, 2 }; //Approved! public static boolean checkSpace(World world, int x, int y, int z, int[] i) { diff --git a/com/hbm/inventory/FluidTank.java b/com/hbm/inventory/FluidTank.java index 198998adb..bc9c8681c 100644 --- a/com/hbm/inventory/FluidTank.java +++ b/com/hbm/inventory/FluidTank.java @@ -20,7 +20,7 @@ public class FluidTank { int maxFluid; public boolean takeIn = true; public boolean letOut = false; - int index; + public int index; public FluidTank(FluidType type, int maxFluid, int index) { this.type = type; diff --git a/com/hbm/inventory/container/ContainerMachineAssembler.java b/com/hbm/inventory/container/ContainerMachineAssembler.java index 28de4eb39..bb57d7103 100644 --- a/com/hbm/inventory/container/ContainerMachineAssembler.java +++ b/com/hbm/inventory/container/ContainerMachineAssembler.java @@ -70,16 +70,15 @@ private TileEntityMachineAssembler nukeBoy; ItemStack var5 = var4.getStack(); var3 = var5.copy(); - if (par2 <= 12) { - if (!this.mergeItemStack(var5, 13, this.inventorySlots.size(), true)) + if (par2 <= 17) { + if (!this.mergeItemStack(var5, 18, this.inventorySlots.size(), true)) { return null; } } - else if (!this.mergeItemStack(var5, 0, 13, false)) - { + else if (!this.mergeItemStack(var5, 6, 18, false)) + if (!this.mergeItemStack(var5, 0, 4, false)) return null; - } if (var5.stackSize == 0) { diff --git a/com/hbm/inventory/container/ContainerMachineChemplant.java b/com/hbm/inventory/container/ContainerMachineChemplant.java new file mode 100644 index 000000000..586c86e02 --- /dev/null +++ b/com/hbm/inventory/container/ContainerMachineChemplant.java @@ -0,0 +1,154 @@ +package com.hbm.inventory.container; + +import com.hbm.inventory.SlotMachineOutput; +import com.hbm.tileentity.TileEntityMachineAssembler; +import com.hbm.tileentity.TileEntityMachineChemplant; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.ICrafting; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerMachineChemplant extends Container { + +private TileEntityMachineChemplant nukeBoy; + + private int power; + private int progress; + private int maxProgress; + + public ContainerMachineChemplant(InventoryPlayer invPlayer, TileEntityMachineChemplant tedf) { + + nukeBoy = tedf; + + //Battery + this.addSlotToContainer(new Slot(tedf, 0, 80, 18)); + //Upgrades + this.addSlotToContainer(new Slot(tedf, 1, 116, 18)); + this.addSlotToContainer(new Slot(tedf, 2, 116, 36)); + this.addSlotToContainer(new Slot(tedf, 3, 116, 54)); + //Schematic + this.addSlotToContainer(new Slot(tedf, 4, 80, 54)); + //Outputs + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 5, 134, 90)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 6, 152, 90)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 7, 134, 108)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 8, 152, 108)); + //Fluid Output In + this.addSlotToContainer(new Slot(tedf, 9, 134, 54)); + this.addSlotToContainer(new Slot(tedf, 10, 152, 54)); + //Fluid Outputs Out + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 11, 134, 72)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 12, 152, 72)); + //Input + this.addSlotToContainer(new Slot(tedf, 13, 8, 90)); + this.addSlotToContainer(new Slot(tedf, 14, 26, 90)); + this.addSlotToContainer(new Slot(tedf, 15, 8, 108)); + this.addSlotToContainer(new Slot(tedf, 16, 26, 108)); + //Fluid Input In + this.addSlotToContainer(new Slot(tedf, 17, 8, 54)); + this.addSlotToContainer(new Slot(tedf, 18, 26, 54)); + //Fluid Input Out + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 19, 8, 72)); + this.addSlotToContainer(new SlotMachineOutput(invPlayer.player, tedf, 20, 26, 72)); + + for(int i = 0; i < 3; i++) + { + for(int j = 0; j < 9; j++) + { + this.addSlotToContainer(new Slot(invPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18 + 56)); + } + } + + for(int i = 0; i < 9; i++) + { + this.addSlotToContainer(new Slot(invPlayer, i, 8 + i * 18, 142 + 56)); + } + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer p_82846_1_, int par2) + { + ItemStack var3 = null; + Slot var4 = (Slot) this.inventorySlots.get(par2); + + if (var4 != null && var4.getHasStack()) + { + ItemStack var5 = var4.getStack(); + var3 = var5.copy(); + + if (par2 <= 17) { + if (!this.mergeItemStack(var5, 18, this.inventorySlots.size(), true)) + { + return null; + } + } + else if (!this.mergeItemStack(var5, 6, 18, false)) + if (!this.mergeItemStack(var5, 0, 4, false)) + return null; + + if (var5.stackSize == 0) + { + var4.putStack((ItemStack) null); + } + else + { + var4.onSlotChanged(); + } + } + + return var3; + } + + @Override + public boolean canInteractWith(EntityPlayer player) { + return nukeBoy.isUseableByPlayer(player); + } + + @Override + public void detectAndSendChanges() { + super.detectAndSendChanges(); + + for(int i = 0; i < this.crafters.size(); i++) + { + ICrafting par1 = (ICrafting)this.crafters.get(i); + + if(this.power != this.nukeBoy.power) + { + par1.sendProgressBarUpdate(this, 0, this.nukeBoy.power); + } + + if(this.progress != this.nukeBoy.progress) + { + par1.sendProgressBarUpdate(this, 1, this.nukeBoy.progress); + } + + if(this.maxProgress != this.nukeBoy.maxProgress) + { + par1.sendProgressBarUpdate(this, 2, this.nukeBoy.maxProgress); + } + } + + this.power = this.nukeBoy.power; + this.progress= this.nukeBoy.progress; + this.maxProgress= this.nukeBoy.maxProgress; + } + + @Override + public void updateProgressBar(int i, int j) { + if(i == 0) + { + nukeBoy.power = j; + } + if(i == 1) + { + nukeBoy.progress = j; + } + if(i == 2) + { + nukeBoy.maxProgress = j; + } + } +} diff --git a/com/hbm/inventory/gui/GUIMachineChemplant.java b/com/hbm/inventory/gui/GUIMachineChemplant.java new file mode 100644 index 000000000..18196b6e5 --- /dev/null +++ b/com/hbm/inventory/gui/GUIMachineChemplant.java @@ -0,0 +1,50 @@ +package com.hbm.inventory.gui; + +import org.lwjgl.opengl.GL11; + +import com.hbm.inventory.container.ContainerMachineAssembler; +import com.hbm.inventory.container.ContainerMachineChemplant; +import com.hbm.lib.RefStrings; +import com.hbm.tileentity.TileEntityMachineAssembler; +import com.hbm.tileentity.TileEntityMachineChemplant; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; + +public class GUIMachineChemplant extends GuiContainer { + + private static ResourceLocation texture = new ResourceLocation(RefStrings.MODID + ":textures/gui/gui_chemplant.png"); + private TileEntityMachineChemplant assembler; + + public GUIMachineChemplant(InventoryPlayer invPlayer, TileEntityMachineChemplant tedf) { + super(new ContainerMachineChemplant(invPlayer, tedf)); + assembler = tedf; + + this.xSize = 176; + this.ySize = 222; + } + + @Override + protected void drawGuiContainerForegroundLayer( int i, int j) { + String name = this.assembler.hasCustomInventoryName() ? this.assembler.getInventoryName() : I18n.format(this.assembler.getInventoryName()); + + this.fontRendererObj.drawString(name, this.xSize / 2 - this.fontRendererObj.getStringWidth(name) / 2, 6, 4210752); + this.fontRendererObj.drawString(I18n.format("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float p_146976_1_, int p_146976_2_, int p_146976_3_) { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + Minecraft.getMinecraft().getTextureManager().bindTexture(texture); + drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize); + + int i = assembler.getPowerScaled(52); + drawTexturedModalRect(guiLeft + 116, guiTop + 70 - i, 176, 52 - i, 16, i); + + int j = assembler.getProgressScaled(83); + drawTexturedModalRect(guiLeft + 45, guiTop + 82, 2, 222, j, 32); + } +} diff --git a/com/hbm/items/ModItems.java b/com/hbm/items/ModItems.java index 6b476cfda..a93dca195 100644 --- a/com/hbm/items/ModItems.java +++ b/com/hbm/items/ModItems.java @@ -506,6 +506,7 @@ public class ModItems { public static Item oil_detector; public static Item assembly_template; + public static Item chemistry_template; public static Item fluid_identifier; public static Item missile_generic; @@ -1663,6 +1664,7 @@ public class ModItems { oil_detector = new ItemOilDetector().setUnlocalizedName("oil_detector").setMaxStackSize(1).setCreativeTab(MainRegistry.tabNuke).setTextureName(RefStrings.MODID + ":oil_detector"); assembly_template = new ItemAssemblyTemplate().setUnlocalizedName("assembly_template").setMaxStackSize(1).setCreativeTab(MainRegistry.tabMachine).setTextureName(RefStrings.MODID + ":assembly_template"); + chemistry_template = new ItemChemistryTemplate().setUnlocalizedName("chemistry_template").setMaxStackSize(1).setCreativeTab(MainRegistry.tabMachine).setTextureName(RefStrings.MODID + ":chemistry_template"); fluid_identifier = new ItemFluidIdentifier().setUnlocalizedName("fluid_identifier").setMaxStackSize(1).setCreativeTab(MainRegistry.tabMachine).setTextureName(RefStrings.MODID + ":fluid_identifier"); euphemium_helmet = new ArmorEuphemium(MainRegistry.enumArmorMaterialEuphemium, 6, 0).setUnlocalizedName("astatine_helmet").setMaxStackSize(1).setTextureName(RefStrings.MODID + ":euphemium_helmet"); @@ -2280,6 +2282,7 @@ public class ModItems { //Machine Templates GameRegistry.registerItem(fluid_identifier, fluid_identifier.getUnlocalizedName()); GameRegistry.registerItem(assembly_template, assembly_template.getUnlocalizedName()); + GameRegistry.registerItem(chemistry_template, chemistry_template.getUnlocalizedName()); //Machine Items GameRegistry.registerItem(fuse, fuse.getUnlocalizedName()); diff --git a/com/hbm/items/tool/ItemChemistryTemplate.java b/com/hbm/items/tool/ItemChemistryTemplate.java new file mode 100644 index 000000000..fb773cf4c --- /dev/null +++ b/com/hbm/items/tool/ItemChemistryTemplate.java @@ -0,0 +1,94 @@ +package com.hbm.items.tool; + +import java.util.List; + +import com.hbm.inventory.MachineRecipes; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class ItemChemistryTemplate extends Item { + + public enum EnumChemistryTemplate { + + TEST; + + public static EnumChemistryTemplate getEnum(int i) { + return EnumChemistryTemplate.values()[i]; + } + + public String getName() { + return this.toString(); + } + } + + public ItemChemistryTemplate() + { + this.setHasSubtypes(true); + this.setMaxDamage(0); + } + + @Override + public String getUnlocalizedName(ItemStack stack) + { + int i = stack.getItemDamage(); + return super.getUnlocalizedName() + "." + EnumChemistryTemplate.getEnum(i).getName(); + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item item, CreativeTabs tabs, List list) + { + for (int i = 0; i < EnumChemistryTemplate.values().length; ++i) + { + list.add(new ItemStack(item, 1, i)); + } + } + + public static int getProcessTime(ItemStack stack) { + + if(!(stack.getItem() instanceof ItemChemistryTemplate)) + return 100; + + int i = stack.getItemDamage(); + EnumChemistryTemplate enum1 = EnumChemistryTemplate.getEnum(i); + + switch (enum1) { + case TEST: + return 200; + default: + return 100; + } + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) + { + + /*if(!(stack.getItem() instanceof ItemChemistryTemplate)) + return; + + List stacks = MachineRecipes.getRecipeFromTempate(stack); + ItemStack out = MachineRecipes.getOutputFromTempate(stack); + + try { + list.add("Output:"); + list.add(out.stackSize + "x " + out.getDisplayName()); + list.add("Inputs:"); + + for(int i = 0; i < stacks.size(); i++) { + if(stacks.get(i) != null) + list.add(stacks.get(i).stackSize + "x " + stacks.get(i).getDisplayName()); + } + list.add("Production time:"); + list.add(Math.floor((float)(getProcessTime(stack)) / 20 * 100) / 100 + " seconds"); + } catch(Exception e) { + list.add("###INVALID###"); + list.add("0x334077-0x6A298F-0xDF3795-0x334077"); + }*/ + } + +} diff --git a/com/hbm/main/MainRegistry.java b/com/hbm/main/MainRegistry.java index 8e669a52c..ee68a974b 100644 --- a/com/hbm/main/MainRegistry.java +++ b/com/hbm/main/MainRegistry.java @@ -367,6 +367,8 @@ public class MainRegistry Library.superuser.add("3af1c262-61c0-4b12-a4cb-424cc3a9c8c0"); Library.superuser.add("4729b498-a81c-42fd-8acd-20d6d9f759e0"); Library.superuser.add("c3f5e449-6d8c-4fe3-acc9-47ef50e7e7ae"); + //until he manages to do the most basic thing and INSTALL NEI + //Library.superuser.add("122fe98f-be19-49ca-a96b-d4dee4f0b22e"); Library.initBooks(); diff --git a/com/hbm/tileentity/TileEntityMachineChemplant.java b/com/hbm/tileentity/TileEntityMachineChemplant.java index 1fc5cecf0..86b26f473 100644 --- a/com/hbm/tileentity/TileEntityMachineChemplant.java +++ b/com/hbm/tileentity/TileEntityMachineChemplant.java @@ -1,7 +1,564 @@ package com.hbm.tileentity; +import java.util.List; +import java.util.Random; + +import com.hbm.handler.FluidTypeHandler.FluidType; +import com.hbm.interfaces.IConsumer; +import com.hbm.interfaces.IFluidContainer; +import com.hbm.inventory.FluidTank; +import com.hbm.inventory.MachineRecipes; +import com.hbm.items.ModItems; +import com.hbm.items.special.ItemBattery; +import com.hbm.items.tool.ItemAssemblyTemplate; +import com.hbm.lib.Library; +import com.hbm.packet.PacketDispatcher; +import com.hbm.packet.TEAssemblerPacket; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; import net.minecraft.tileentity.TileEntity; +import net.minecraft.tileentity.TileEntityChest; +import net.minecraft.tileentity.TileEntityHopper; +import net.minecraft.util.AxisAlignedBB; +import net.minecraftforge.oredict.OreDictionary; -public class TileEntityMachineChemplant extends TileEntity { +public class TileEntityMachineChemplant extends TileEntity implements ISidedInventory, IConsumer, IFluidContainer { + private ItemStack slots[]; + + public int power; + public static final int maxPower = 100000; + public int progress; + public int maxProgress = 100; + public float rotation = 0; + int age = 0; + int consumption = 100; + int speed = 100; + public FluidTank[] tanks; + + Random rand = new Random(); + + private String customName; + + public TileEntityMachineChemplant() { + slots = new ItemStack[21]; + tanks = new FluidTank[4]; + tanks[0] = new FluidTank(FluidType.NONE, 16000, 0); + tanks[1] = new FluidTank(FluidType.NONE, 16000, 0); + tanks[2] = new FluidTank(FluidType.NONE, 16000, 0); + tanks[3] = new FluidTank(FluidType.NONE, 16000, 0); + tanks[0].index = 0; + tanks[1].index = 1; + tanks[2].index = 2; + tanks[3].index = 3; + tanks[0].takeIn = true; + tanks[1].takeIn = true; + tanks[2].takeIn = false; + tanks[3].takeIn = false; + tanks[0].letOut = false; + tanks[1].letOut = false; + tanks[2].letOut = true; + tanks[3].letOut = true; + } + + @Override + public int getSizeInventory() { + return slots.length; + } + + @Override + public ItemStack getStackInSlot(int i) { + return slots[i]; + } + + @Override + public ItemStack getStackInSlotOnClosing(int i) { + if(slots[i] != null) + { + ItemStack itemStack = slots[i]; + slots[i] = null; + return itemStack; + } else { + return null; + } + } + + @Override + public void setInventorySlotContents(int i, ItemStack itemStack) { + slots[i] = itemStack; + if(itemStack != null && itemStack.stackSize > getInventoryStackLimit()) + { + itemStack.stackSize = getInventoryStackLimit(); + } + } + + @Override + public String getInventoryName() { + return this.hasCustomInventoryName() ? this.customName : "container.chemplant"; + } + + @Override + public boolean hasCustomInventoryName() { + return this.customName != null && this.customName.length() > 0; + } + + public void setCustomName(String name) { + this.customName = name; + } + + @Override + public int getInventoryStackLimit() { + return 64; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer player) { + if(worldObj.getTileEntity(xCoord, yCoord, zCoord) != this) + { + return false; + }else{ + return player.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <=128; + } + } + + //You scrubs aren't needed for anything (right now) + @Override + public void openInventory() {} + @Override + public void closeInventory() {} + + @Override + public boolean isItemValidForSlot(int i, ItemStack itemStack) { + if(i == 0) + if(itemStack.getItem() instanceof ItemBattery) + return true; + + if(i == 1) + return true; + + return false; + } + + @Override + public ItemStack decrStackSize(int i, int j) { + if(slots[i] != null) + { + if(slots[i].stackSize <= j) + { + ItemStack itemStack = slots[i]; + slots[i] = null; + return itemStack; + } + ItemStack itemStack1 = slots[i].splitStack(j); + if (slots[i].stackSize == 0) + { + slots[i] = null; + } + + return itemStack1; + } else { + return null; + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + NBTTagList list = nbt.getTagList("items", 10); + + this.power = nbt.getInteger("powerTime"); + slots = new ItemStack[getSizeInventory()]; + + for(int i = 0; i < list.tagCount(); i++) + { + NBTTagCompound nbt1 = list.getCompoundTagAt(i); + byte b0 = nbt1.getByte("slot"); + if(b0 >= 0 && b0 < slots.length) + { + slots[b0] = ItemStack.loadItemStackFromNBT(nbt1); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("powerTime", power); + NBTTagList list = new NBTTagList(); + + for(int i = 0; i < slots.length; i++) + { + if(slots[i] != null) + { + NBTTagCompound nbt1 = new NBTTagCompound(); + nbt1.setByte("slot", (byte)i); + slots[i].writeToNBT(nbt1); + list.appendTag(nbt1); + } + } + nbt.setTag("items", list); + } + + @Override + public int[] getAccessibleSlotsFromSide(int p_94128_1_) + { + return new int[] { 0 }; + } + + @Override + public boolean canInsertItem(int i, ItemStack itemStack, int j) { + return this.isItemValidForSlot(i, itemStack); + } + + @Override + public boolean canExtractItem(int i, ItemStack itemStack, int j) { + return false; + } + + public int getPowerScaled(int i) { + return (power * i) / maxPower; + } + + public int getProgressScaled(int i) { + return (progress * i) / maxProgress; + } + + @Override + public void updateEntity() { + + if(!worldObj.isRemote) + { + power = Library.chargeTEFromItems(slots, 0, power, maxPower); + + tanks[0].loadTank(17, 19, slots); + tanks[1].loadTank(18, 20, slots); + tanks[2].unloadTank(9, 11, slots); + tanks[3].unloadTank(10, 12, slots); + } + + } + + //I can't believe that worked. + public ItemStack[] cloneItemStackProper(ItemStack[] array) { + ItemStack[] stack = new ItemStack[array.length]; + + for(int i = 0; i < array.length; i++) + if(array[i] != null) + stack[i] = array[i].copy(); + else + stack[i] = null; + + return stack; + } + + //Unloads output into chests + public boolean tryFillContainer(IInventory inventory, int slot) { + + int size = inventory.getSizeInventory(); + + for(int i = 0; i < size; i++) { + if(inventory.getStackInSlot(i) != null) { + + if(slots[slot] == null) + return false; + + ItemStack sta1 = inventory.getStackInSlot(i).copy(); + ItemStack sta2 = slots[slot].copy(); + if(sta1 != null && sta2 != null) { + sta1.stackSize = 1; + sta2.stackSize = 1; + + if(ItemStack.areItemStacksEqual(sta1, sta2) && ItemStack.areItemStackTagsEqual(sta1, sta2) && inventory.getStackInSlot(i).stackSize < inventory.getStackInSlot(i).getMaxStackSize()) { + slots[slot].stackSize--; + + if(slots[slot].stackSize <= 0) + slots[slot] = null; + + ItemStack sta3 = inventory.getStackInSlot(i).copy(); + sta3.stackSize++; + inventory.setInventorySlotContents(i, sta3); + + return true; + } + } + } + } + for(int i = 0; i < size; i++) { + + if(slots[slot] == null) + return false; + + ItemStack sta2 = slots[slot].copy(); + if(inventory.getStackInSlot(i) == null && sta2 != null) { + sta2.stackSize = 1; + slots[slot].stackSize--; + + if(slots[slot].stackSize <= 0) + slots[slot] = null; + + inventory.setInventorySlotContents(i, sta2); + + return true; + } + } + + return false; + } + + //Loads assembler's input queue from chests + public boolean tryFillAssembler(IInventory inventory, int slot) { + + if(MachineRecipes.getOutputFromTempate(slots[4]) == null || MachineRecipes.getRecipeFromTempate(slots[4]) == null) + return false; + else { + List list = MachineRecipes.getRecipeFromTempate(slots[4]); + + for(int i = 0; i < list.size(); i++) + list.get(i).stackSize = 1; + + + if(inventory.getStackInSlot(slot) == null) + return false; + + ItemStack stack = inventory.getStackInSlot(slot).copy(); + stack.stackSize = 1; + + boolean flag = false; + + for(int i = 0; i < list.size(); i++) + if(ItemStack.areItemStacksEqual(stack, list.get(i)) && ItemStack.areItemStackTagsEqual(stack, list.get(i))) + flag = true; + + if(!flag) + return false; + + } + + for(int i = 6; i < 18; i++) { + + if(slots[i] != null) { + + ItemStack sta1 = inventory.getStackInSlot(slot).copy(); + ItemStack sta2 = slots[i].copy(); + if(sta1 != null && sta2 != null) { + sta1.stackSize = 1; + sta2.stackSize = 1; + + if(ItemStack.areItemStacksEqual(sta1, sta2) && ItemStack.areItemStackTagsEqual(sta1, sta2) && slots[i].stackSize < slots[i].getMaxStackSize()) { + ItemStack sta3 = inventory.getStackInSlot(slot).copy(); + sta3.stackSize--; + if(sta3.stackSize <= 0) + sta3 = null; + inventory.setInventorySlotContents(slot, sta3); + + slots[i].stackSize++; + return true; + } + } + } + } + + for(int i = 6; i < 18; i++) { + + ItemStack sta2 = inventory.getStackInSlot(slot).copy(); + if(slots[i] == null && sta2 != null) { + sta2.stackSize = 1; + slots[i] = sta2.copy(); + + ItemStack sta3 = inventory.getStackInSlot(slot).copy(); + sta3.stackSize--; + if(sta3.stackSize <= 0) + sta3 = null; + inventory.setInventorySlotContents(slot, sta3); + + return true; + } + } + + return false; + } + + public boolean hasSpace(ItemStack stack) { + + ItemStack st = stack.copy(); + + if(st == null) + return true; + + for(int i = 1; i < 10; i++) { + if(slots[i] == null) + return true; + } + + int size = st.stackSize; + st.stackSize = 1; + + ItemStack[] fakeArray = slots.clone(); + boolean flag = true; + for(int i = 0; i < stack.stackSize; i++) { + if(!canAddItemToArray(st, fakeArray)) + flag = false; + } + + return flag; + } + + public void addItemToInventory(ItemStack stack) { + + ItemStack st = stack.copy(); + + if(st == null) + return; + + int size = st.stackSize; + st.stackSize = 1; + + for(int i = 0; i < size; i++) + canAddItemToArray(st, this.slots); + + } + + public boolean canAddItemToArray(ItemStack stack, ItemStack[] array) { + + ItemStack st = stack.copy(); + + if(st == null) + return true; + + for(int i = 1; i < 10; i++) { + + if(array[i] != null) { + ItemStack sta = array[i].copy(); + + if(sta != null && sta.getItem() == st.getItem() && sta.stackSize < st.getMaxStackSize()) { + array[i].stackSize++; + return true; + } + } + } + + for(int i = 1; i < 10; i++) { + if(array[i] == null) { + array[i] = stack.copy(); + return true; + } + } + + return false; + } + + //boolean true: remove items, boolean false: simulation mode + public boolean removeItems(List stack, ItemStack[] array) { + + if(stack == null) + return false; + + for(int i = 0; i < stack.size(); i++) { + for(int j = 0; j < stack.get(i).stackSize; j++) { + ItemStack sta = stack.get(i).copy(); + sta.stackSize = 1; + + if(!canRemoveItemFromArray(sta, array)) + return false; + } + } + + return true; + + } + + public boolean canRemoveItemFromArray(ItemStack stack, ItemStack[] array) { + + ItemStack st = stack.copy(); + + if(st == null) + return true; + + for(int i = 6; i < 18; i++) { + + if(array[i] != null) { + ItemStack sta = array[i].copy(); + sta.stackSize = 1; + + if(sta != null && isItemAcceptible(sta, st) && array[i].stackSize > 0) { + array[i].stackSize--; + + if(array[i].stackSize <= 0) + array[i] = null; + + return true; + } + } + } + + return false; + } + + public boolean isItemAcceptible(ItemStack stack1, ItemStack stack2) { + + if(stack1 != null && stack2 != null) { + if(ItemStack.areItemStacksEqual(stack1, stack2)) + return true; + + int[] ids1 = OreDictionary.getOreIDs(stack1); + int[] ids2 = OreDictionary.getOreIDs(stack2); + + if(ids1 != null && ids2 != null && ids1.length > 0 && ids2.length > 0) { + for(int i = 0; i < ids1.length; i++) + for(int j = 0; j < ids2.length; j++) + if(ids1[i] == ids2[j]) + return true; + } + } + + return false; + } + + @Override + public void setPower(int i) { + power = i; + + } + + @Override + public int getPower() { + return power; + + } + + @Override + public int getMaxPower() { + return maxPower; + } + + @Override + public AxisAlignedBB getRenderBoundingBox() { + return TileEntity.INFINITE_EXTENT_AABB; + } + + @Override + @SideOnly(Side.CLIENT) + public double getMaxRenderDistanceSquared() + { + return 65536.0D; + } + + @Override + public void setFillstate(int fill, int index) { + if(index < 4 && tanks[index] != null) + tanks[index].setFill(fill); + } + + @Override + public void setType(FluidType type, int index) { + if(index < 4 && tanks[index] != null) + tanks[index].setTankType(type); + } }