From 05c78126859231a68e199dc34613689bd0978e2f Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Mon, 11 Apr 2016 19:44:54 +0300 Subject: Initial commit --- ihl/flexible_cable/IronWorkbenchTileEntity.java | 367 ++++++++++++++++++++++++ 1 file changed, 367 insertions(+) create mode 100644 ihl/flexible_cable/IronWorkbenchTileEntity.java (limited to 'ihl/flexible_cable/IronWorkbenchTileEntity.java') diff --git a/ihl/flexible_cable/IronWorkbenchTileEntity.java b/ihl/flexible_cable/IronWorkbenchTileEntity.java new file mode 100644 index 0000000..3821a0c --- /dev/null +++ b/ihl/flexible_cable/IronWorkbenchTileEntity.java @@ -0,0 +1,367 @@ +package ihl.flexible_cable; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import ic2.api.network.INetworkClientTileEntityEventListener; +import ic2.api.network.INetworkTileEntityEventListener; +import ic2.api.recipe.IRecipeInput; +import ic2.api.recipe.RecipeInputItemStack; +import ic2.core.ContainerBase; +import ic2.core.IC2; +import ic2.core.IHasGui; +import ic2.core.Ic2Items; +import ic2.core.block.TileEntityInventory; +import ic2.core.block.invslot.InvSlot.Access; +import ihl.IHLMod; +import ihl.interfaces.IWire; +import ihl.items_blocks.FlexibleCableItem; +import ihl.processing.chemistry.GaedesMercuryRotaryPumpTileEntity; +import ihl.processing.metallurgy.GasWeldingStationTileEntity; +import ihl.recipes.IronWorkbenchRecipe; +import ihl.recipes.RecipeInputDie; +import ihl.recipes.RecipeInputObjectInstance; +import ihl.utils.IHLUtils; + +public class IronWorkbenchTileEntity extends TileEntityInventory implements IHasGui, INetworkClientTileEntityEventListener, INetworkTileEntityEventListener{ + + public static List recipes = new ArrayList(); + public int progress; + public int currentSlot=-1; + public final int maxProgress; + public final InvSlotTool tools; + public final InvSlotWorkspaceElement workspaceElements; + public final InvSlotProcessableIronWorkbench inputMaterial; + public final InvSlotOutputInProgress output; + public boolean isGuiScreenOpened=false; + private boolean startProcess=false; + private boolean outputDefined=false; + private EntityPlayer crafter; + public ContainerBase container; + private Map slotRecipeMap = new HashMap(); + + public IronWorkbenchTileEntity() + { + this.maxProgress=80; + this.workspaceElements = new InvSlotWorkspaceElement(this, "workspaceElements", 3, Access.NONE, 6); + this.tools=new InvSlotTool(this, "tools", 0, Access.IO, 12); + this.inputMaterial=new InvSlotProcessableIronWorkbench(this, "input", 1, Access.IO, 12); + this.output=new InvSlotOutputInProgress(this, "output", 2, 18); + } + + public static void addRecipe(IronWorkbenchRecipe recipe) + { + IronWorkbenchTileEntity.recipes.add(recipe); + } + + @Override + public String getInventoryName() + { + return "ironWorkbench"; + } + + + @Override + public ItemStack getWrenchDrop(EntityPlayer player) + { + return IHLUtils.getThisModItemStack("ironWorkbench"); + } + + @Override + public void updateEntityServer() + { + if(this.isGuiScreenOpened) + { + if(this.output.isEmpty() && !outputDefined) + { + this.workspaceElements.reset(); + Iterator iwri=IronWorkbenchTileEntity.recipes.iterator(); + while(iwri.hasNext()) + { + IronWorkbenchRecipe recipe = iwri.next(); + if(recipe.isCanBeCrafted(this.tools.getItemStackList(), this.inputMaterial.getItemStackList(), this.workspaceElements.getItemStackList())) + { + if(recipe.workspaceElements==null || recipe.workspaceElements.isEmpty() || this.workspaceElements.containsAndCanUse(recipe.workspaceElements)) + { + List newOutputs = recipe.outputs; + for(IRecipeInput rinput:recipe.tools) + { + if(rinput instanceof RecipeInputDie) + { + newOutputs = ((RecipeInputDie)rinput).transformOutput(this.getMatchedItemStack(rinput),recipe.outputs); + } + } + int slot = this.output.put(newOutputs); + if(slot<0)break; + slotRecipeMap.put(slot, recipe); + this.startProcess=false; + } + } + } + List processingMaterials = new ArrayList(); + for(int i=0; i list = this.getListOfSameWires(stack); + ItemStack result = stack.copy(); + result.stackTagCompound.setInteger("length", fullLength); + result.stackTagCompound.setInteger("fullLength", fullLength); + IronWorkbenchRecipe recipe = new IronWorkbenchRecipe(null, list, Arrays.asList(new ItemStack[] {result})); + int slot = this.output.put(recipe.outputs); + if(slot<0)break; + slotRecipeMap.put(slot, recipe); + this.startProcess=false; + break; + } + } + outputDefined=true; + } + else if(!this.output.isEmpty()) + { + List crafterEmptyInventorySlotsList = getCrafterEmptyInventorySlotsList(); + if(startProcess && crafterEmptyInventorySlotsList.size()>=this.slotRecipeMap.get(currentSlot).outputs.size()) + { + if(++this.progress>=this.maxProgress) + { + IronWorkbenchRecipe crecipe = this.slotRecipeMap.get(currentSlot); + List opts = this.output.getRecipeOutputs(currentSlot); + int multiplier = this.inputMaterial.getMultiplier(crecipe.materials); + Iterator optsi = opts.iterator(); + Iterator emptySlotsIterator = crafterEmptyInventorySlotsList.iterator(); + while(optsi.hasNext()) + { + int slot = emptySlotsIterator.next(); + ItemStack stack = optsi.next(); + this.crafter.inventory.mainInventory[slot]=stack.copy(); + if(stack.getItem() instanceof IWire) + { + System.out.println(multiplier); + this.crafter.inventory.mainInventory[slot]=IHLUtils.getWireItemStackCopyWithLengthMultiplied(stack,multiplier); + } + else + { + this.crafter.inventory.mainInventory[slot]=stack.copy(); + this.crafter.inventory.mainInventory[slot].stackSize*=multiplier; + } + } + this.crafter.inventoryContainer.detectAndSendChanges(); + this.inputMaterial.substract(crecipe.materials, multiplier); + this.tools.damage(crecipe.tools); + if(!crecipe.workspaceElements.isEmpty()) + { + this.workspaceElements.use(crecipe.workspaceElements); + } + this.resetOutput(); + } + } + } + } + } + + private ItemStack getMatchedItemStack(IRecipeInput rinput) + { + for(ItemStack tool:this.tools.getItemStackList()) + { + if(rinput.matches(tool)) + { + return tool; + } + } + for(ItemStack material:this.inputMaterial.getItemStackList()) + { + if(rinput.matches(material)) + { + return material; + } + } + + return null; + } + + private List getCrafterEmptyInventorySlotsList() + { + List list = new ArrayList(); + if(this.crafter!=null) + { + for (int var1 = 0; var1 < this.crafter.inventory.mainInventory.length; ++var1) + { + if (this.crafter.inventory.mainInventory[var1] == null) + { + list.add(var1); + } + } + } + return list; + } + + private List getListOfSameWires(ItemStack stack1) { + List list = new ArrayList(); + for(int i=0; i getGuiContainer(EntityPlayer player) { + resetOutput(); + this.isGuiScreenOpened=true; + this.crafter=player; + container = new IronWorkbenchContainer(player, this); + return container; + } + + @Override + public void onGuiClosed(EntityPlayer arg0) + { + this.isGuiScreenOpened=false; + } + + @Override + public void onNetworkEvent(EntityPlayer player, int event) + { + if(event==16) + { + this.isGuiScreenOpened=false; + this.crafter=null; + this.container=null; + return; + } + for(int i=event;i>=0;i--) + { + if(this.slotRecipeMap.containsKey(i)) + { + if(!this.slotRecipeMap.get(i).isCanBeCrafted(this.tools.getItemStackList(), this.inputMaterial.getItemStackList(), this.workspaceElements.getItemStackList())) + { + resetOutput(); + } + else + { + this.currentSlot=i; + this.startProcess=true; + return; + } + } + } + } + + public void resetOutput() + { + this.output.clear(); + this.slotRecipeMap.clear(); + this.progress=0; + this.startProcess=false; + this.currentSlot=-1; + this.outputDefined=false; + } + + + public void dropContents() { + for(int i=0;i recipeOutputsItems) + { + Iterator ri = recipes.iterator(); + while(ri.hasNext()) + { + IronWorkbenchRecipe recipe = ri.next(); + boolean removeEntry=false; + Iterator roi = recipe.outputs.iterator(); + while(roi.hasNext()) + { + if(IHLUtils.isItemStacksIsEqual(recipeOutputsItems.get(0), roi.next(), true)) + { + removeEntry=true; + } + } + if(removeEntry) + { + ri.remove(); + } + } + + } + + public static void removeRecipeByInput(List recipeInputsTools1,List recipeInputsItems1,List recipeInputsMachines) { + List recipeInputsTools = IHLUtils.convertRecipeInputToItemStackList(recipeInputsTools1); + List recipeInputsItems = IHLUtils.convertRecipeInputToItemStackList(recipeInputsItems1); + Iterator ri = recipes.iterator(); + while(ri.hasNext()) + { + IronWorkbenchRecipe recipe = ri.next(); + if(recipe.isCanBeCrafted(recipeInputsTools, recipeInputsItems, recipeInputsMachines)) + { + ri.remove(); + } + } + + } + +} -- cgit v1.2.3