full project files

1 files changed, 0 insertions, 351 deletions

diff --git a/ihl/flexible_cable/IronWorkbenchTileEntity.java b/ihl/flexible_cable/IronWorkbenchTileEntity.java
deleted file mode 100644
index 30f6fda..0000000
--- a/ihl/flexible_cable/IronWorkbenchTileEntity.java
+++ /dev/null
@@ -1,351 +0,0 @@
-package ihl.flexible_cable;

-

-import java.util.ArrayList;

-import java.util.Arrays;

-import java.util.HashMap;

-import java.util.HashSet;

-import java.util.Iterator;

-import java.util.List;

-import java.util.Map;

-import java.util.Set;

-

-import cpw.mods.fml.relauncher.Side;

-import cpw.mods.fml.relauncher.SideOnly;

-import ic2.api.network.INetworkClientTileEntityEventListener;

-import ic2.api.network.INetworkTileEntityEventListener;

-import ic2.api.recipe.IRecipeInput;

-import ic2.core.ContainerBase;

-import ic2.core.IHasGui;

-import ic2.core.block.TileEntityInventory;

-import ic2.core.block.invslot.InvSlot.Access;

-import ihl.IHLMod;

-import ihl.interfaces.IWire;

-import ihl.recipes.IronWorkbenchRecipe;

-import ihl.recipes.RecipeInputDetonator;

-import ihl.recipes.RecipeInputDie;

-import ihl.recipes.RecipeInputObjectInstance;

-import ihl.utils.IHLUtils;

-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 net.minecraft.network.NetworkManager;

-import net.minecraft.network.play.server.S35PacketUpdateTileEntity;

-

-public class IronWorkbenchTileEntity extends TileEntityInventory

-		implements IHasGui, INetworkClientTileEntityEventListener, INetworkTileEntityEventListener {

-

-	public static List<IronWorkbenchRecipe> recipes = new ArrayList<IronWorkbenchRecipe>();

-	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<Integer, IronWorkbenchRecipe> slotRecipeMap = new HashMap<Integer, IronWorkbenchRecipe>();

-	private boolean firstTick = true;

-

-	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

-	@SideOnly(Side.CLIENT)

-	public void updateEntityClient() {

-		if (firstTick) {

-			IHLMod.proxy.requestTileEntityInitdataFromClientToServer(xCoord, yCoord, zCoord);

-			this.firstTick = false;

-		}

-	}

-

-	@Override

-	public void updateEntityServer() {

-		if (this.isGuiScreenOpened) {

-			if (this.output.isEmpty() && !outputDefined) {

-				this.workspaceElements.reset();

-				Iterator<IronWorkbenchRecipe> 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<ItemStack> newOutputs = recipe.outputs;

-							for (IRecipeInput rinput : recipe.tools) {

-								if (rinput instanceof RecipeInputDie) {

-									newOutputs = ((RecipeInputDie) rinput)

-											.transformOutput(this.getMatchedItemStack(rinput), recipe.outputs);

-								}

-							}

-							for (IRecipeInput rinput : recipe.materials) {

-								if (rinput instanceof RecipeInputDetonator) {

-									newOutputs = ((RecipeInputDetonator) rinput)

-											.transformOutput(this.getMatchedItemStack(rinput), recipe.outputs);

-								}

-							}

-							int slot = this.output.put(newOutputs);

-							if (slot < 0)

-								break;

-							slotRecipeMap.put(slot, recipe);

-							this.startProcess = false;

-						}

-					}

-				}

-				for (int i = 0; i < this.inputMaterial.size(); i++) {

-					ItemStack stack = this.inputMaterial.get(i);

-					if (stack != null && stack.getItem() instanceof IWire) {

-						if (stack.stackTagCompound == null) {

-							stack.stackTagCompound = new NBTTagCompound();

-						}

-						int fullLength = this.getFullLengthOfSameWires(stack);

-						List<RecipeInputObjectInstance> 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()) {

-				Set<Integer> crafterEmptyInventorySlotsList = getCrafterEmptyInventorySlotsList();

-				if (startProcess && crafterEmptyInventorySlotsList.size() >= this.slotRecipeMap.get(currentSlot).outputs

-						.size()) {

-					if (++this.progress >= this.maxProgress) {

-						IronWorkbenchRecipe crecipe = this.slotRecipeMap.get(currentSlot);

-						List<ItemStack> opts = this.output.getRecipeOutputs(currentSlot);

-						int multiplier = this.inputMaterial.getMultiplier(crecipe.materials);

-						Iterator<ItemStack> optsi = opts.iterator();

-						Iterator<Integer> emptySlotsIterator = crafterEmptyInventorySlotsList.iterator();

-						while (optsi.hasNext()) {

-							int slot = emptySlotsIterator.next();

-							ItemStack stack = optsi.next();

-							if (stack.getItem() instanceof IWire) {

-								this.crafter.inventory.mainInventory[slot] = IHLUtils

-										.getWireItemStackCopyWithLengthMultiplied(stack, multiplier);

-							} else {

-								this.crafter.inventory.mainInventory[slot] = stack.copy();

-								this.crafter.inventory.mainInventory[slot].stackSize *= multiplier;

-							}

-						}

-						Iterator<ItemStack> emptyContainers = this.inputMaterial

-								.substract(crecipe.materials, multiplier).iterator();

-						while (emptyContainers.hasNext()) {

-							if (emptySlotsIterator.hasNext()) {

-								int slot = emptySlotsIterator.next();

-								ItemStack stack = emptyContainers.next();

-								this.crafter.inventory.mainInventory[slot] = stack.copy();

-								this.crafter.inventory.mainInventory[slot].stackSize *= multiplier;

-							} else {

-								EntityItem eistack = new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1,

-										this.zCoord, emptyContainers.next());

-								this.worldObj.spawnEntityInWorld(eistack);

-							}

-						}

-						this.crafter.inventoryContainer.detectAndSendChanges();

-						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 Set<Integer> getCrafterEmptyInventorySlotsList() {

-		Set<Integer> list = new HashSet<Integer>(4);

-		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<RecipeInputObjectInstance> getListOfSameWires(ItemStack stack1) {

-		List<RecipeInputObjectInstance> list = new ArrayList<RecipeInputObjectInstance>();

-		for (int i = 0; i < this.inputMaterial.size(); i++) {

-			ItemStack stack = this.inputMaterial.get(i);

-			if (stack != null && ((IWire) stack1.getItem()).isSameWire(stack1, stack)) {

-				list.add(new RecipeInputObjectInstance(stack));

-			}

-		}

-		return list;

-	}

-

-	private int getFullLengthOfSameWires(ItemStack stack1) {

-		int fullLength = 0;

-		for (int i = 0; i < this.inputMaterial.size(); i++) {

-			ItemStack stack = this.inputMaterial.get(i);

-			if (stack != null && ((IWire) stack1.getItem()).isSameWire(stack1, stack)) {

-				fullLength += IHLUtils.getWireLength(stack);

-			}

-		}

-		return fullLength;

-	}

-

-	@Override

-	@SideOnly(Side.CLIENT)

-	public GuiScreen getGui(EntityPlayer player, boolean arg1) {

-		return new IronWorkbenchGui(new IronWorkbenchContainer(player, this));

-	}

-

-	@Override

-	public ContainerBase<?> 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 < this.tools.size(); i++) {

-			if (this.tools.get(i) != null)

-				this.worldObj.spawnEntityInWorld(

-						new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1, this.zCoord, this.tools.get(i)));

-		}

-		for (int i = 0; i < this.inputMaterial.size(); i++) {

-			if (this.inputMaterial.get(i) != null)

-				this.worldObj.spawnEntityInWorld(new EntityItem(this.worldObj, this.xCoord, this.yCoord + 1,

-						this.zCoord, this.inputMaterial.get(i)));

-		}

-	}

-

-	@Override

-	public void onNetworkEvent(int event) {

-

-	}

-

-	public int gaugeProgressScaled(int i) {

-		return this.progress * i / this.maxProgress;

-	}

-

-	@Override

-	public boolean shouldRenderInPass(int pass) {

-		return pass == 0;

-	}

-

-	public static void removeRecipeByOutput(List<ItemStack> recipeOutputsItems) {

-		Iterator<IronWorkbenchRecipe> ri = recipes.iterator();

-		while (ri.hasNext()) {

-			IronWorkbenchRecipe recipe = ri.next();

-			boolean removeEntry = false;

-			Iterator<ItemStack> 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<IRecipeInput> recipeInputsTools1, List<IRecipeInput> recipeInputsItems1,

-			List<ItemStack> recipeInputsMachines) {

-		List<ItemStack> recipeInputsTools = IHLUtils.convertRecipeInputToItemStackList(recipeInputsTools1);

-		List<ItemStack> recipeInputsItems = IHLUtils.convertRecipeInputToItemStackList(recipeInputsItems1);

-		Iterator<IronWorkbenchRecipe> ri = recipes.iterator();

-		while (ri.hasNext()) {

-			IronWorkbenchRecipe recipe = ri.next();

-			if (recipe.isCanBeCrafted(recipeInputsTools, recipeInputsItems, recipeInputsMachines)) {

-				ri.remove();

-			}

-		}

-	}

-

-	@Override

-	public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {

-		this.readFromNBT(pkt.func_148857_g());

-	}

-

-}