Minecraft Forums

package CsFreakable.MiningPlus.handler;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import CsFreakable.MiningPlus.block.container.ContainerMergingTable;
import CsFreakable.MiningPlus.block.gui.GuiMergingTable;
import CsFreakable.MiningPlus.core.MP_Blocks;
import cpw.mods.fml.common.network.IGuiHandler;

public class GuiHandlerMergingTable implements IGuiHandler
{
@Override
public Object getClientGuiElement(int id, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity entity = world.getBlockTileEntity(x, y, z);

switch(id)
{
case 0:
return id == 0 && world.getBlockId(x, y, z) == MP_Blocks.mergingTable.blockID ? new GuiMergingTable(player.inventory, world, x, y, z) : null;
}

return null;
}

@Override
public Object getServerGuiElement(int id, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity entity = world.getBlockTileEntity(x, y, z);

switch(id)
{
case 0:
return id == 0 && world.getBlockId(x, y, z) == MP_Blocks.mergingTable.blockID ? new ContainerMergingTable(player.inventory, world, x, y, z) : null;
}

return null;
}
}

package CsFreakable.MiningPlus.block.gui;

import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.resources.I18n;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;
import net.minecraft.world.World;

import org.lwjgl.opengl.GL11;

import CsFreakable.MiningPlus.block.container.ContainerMergingTable;
import CsFreakable.MiningPlus.core.MP_Info;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;

@SideOnly(Side.CLIENT)
public class GuiMergingTable extends GuiContainer
{
private static final ResourceLocation guiTexture = new ResourceLocation(MP_Info.modid + "textures/gui/mergingTable.png");

public GuiMergingTable(InventoryPlayer playerInventory, World world, int x, int y, int z)
{
super(new ContainerMergingTable(playerInventory, world, x, y, z));
}

protected void drawGuiContainerForegrounLayer(int par1, int par2)
{
this.fontRenderer.drawString(I18n.getString("container.crafting"), 28, 6, 4210752);
this.fontRenderer.drawString(I18n.getString("container.inventory"), 8, this.ySize - 96 + 2, 421072);
}

protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.mc.getTextureManager().bindTexture(guiTexture);
int k = (this.width - this.xSize) / 2;
int l = (this.height - this.ySize) / 2;
this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize);
}

}

package CsFreakable.MiningPlus.block.gui.slot;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.PlayerDestroyItemEvent;
import cpw.mods.fml.common.registry.GameRegistry;

public class SlotMergingTable extends Slot
{
private final IInventory craftMatrix;
private EntityPlayer player;
private int amountCrafted;

public SlotMergingTable(EntityPlayer funcPlayer, IInventory funcCraftMatrix, IInventory inventory, int par4, int par5, int par6)
{
super(inventory, par4, par5, par6);
player = funcPlayer;
craftMatrix = funcCraftMatrix;
}

public boolean isItemValid(ItemStack itemstack)
{
return false;
}

public ItemStack dectStackSize(int par1)
{
if(getHasStack())
{
amountCrafted += Math.min(par1, getStack().stackSize);
}
return super.decrStackSize(par1);
}

protected void onCrafting(ItemStack itemstack, int par1)
{
amountCrafted += par1;
}

public void onPickupFromSlot(EntityPlayer funcPlayer, ItemStack itemstack)
{
GameRegistry.onItemCrafted(funcPlayer, itemstack, craftMatrix);

for(int i = 0; i < craftMatrix.getSizeInventory(); ++i)
{
ItemStack fieldItemstack = craftMatrix.getStackInSlot(i);

if(fieldItemstack != null)
{
craftMatrix.decrStackSize(i, 1);

if(fieldItemstack.getItem().hasContainerItem())
{
ItemStack fieldItemstack2 = fieldItemstack.getItem().getContainerItemStack(fieldItemstack);

if(fieldItemstack2.isItemStackDamageable() && fieldItemstack2.getItemDamage() > fieldItemstack2.getMaxDamage())
{
MinecraftForge.EVENT_BUS.post(new PlayerDestroyItemEvent(player, fieldItemstack2));
fieldItemstack2 = null;
}

if(fieldItemstack2 != null && (!fieldItemstack.getItem().doesContainerItemLeaveCraftingGrid(fieldItemstack) || !player.inventory.addItemStackToInventory(fieldItemstack2)))
{
if(craftMatrix.getStackInSlot(i) == null)
{
craftMatrix.setInventorySlotContents(i, fieldItemstack2);
}
else
{
player.dropPlayerItem(fieldItemstack2);
}
}
}
}
}
}
}

package CsFreakable.MiningPlus.crafting;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

import net.minecraft.block.Block;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.world.World;

public class CraftingManagerMergingTable
{
private static final CraftingManagerMergingTable instance = new CraftingManagerMergingTable();
private List recipes = new ArrayList();

public static final CraftingManagerMergingTable getInstance()
{
return instance;
}

private CraftingManagerMergingTable()
{
recipes = new ArrayList();

//recipes here

Collections.sort(this.recipes, new RecipeSorterMergingTable(this));
}

public MergingShapedRecipes addRecipe(ItemStack par1ItemStack, Object ... par2ArrayOfObj)
{
String s = "";
int i = 0;
int j = 0;
int k = 0;

if (par2ArrayOfObj[i] instanceof String[])
{
String[] astring = (String[])((String[])par2ArrayOfObj[i++]);

for (int l = 0; l < astring.length; ++l)
{
String s1 = astring[l];
++k;
j = s1.length();
s = s + s1;
}
}
else
{
while (par2ArrayOfObj[i] instanceof String)
{
String s2 = (String)par2ArrayOfObj[i++];
++k;
j = s2.length();
s = s + s2;
}
}

HashMap hashmap;

for (hashmap = new HashMap(); i < par2ArrayOfObj.length; i += 4)
{
Character character = (Character)par2ArrayOfObj[i];
ItemStack itemstack1 = null;

if (par2ArrayOfObj[i + 1] instanceof Item)
{
itemstack1 = new ItemStack((Item)par2ArrayOfObj[i + 1]);
}
else if (par2ArrayOfObj[i + 1] instanceof Block)
{
itemstack1 = new ItemStack((Block)par2ArrayOfObj[i + 1], 1, 32767);
}
else if (par2ArrayOfObj[i + 1] instanceof ItemStack)
{
itemstack1 = (ItemStack)par2ArrayOfObj[i + 1];
}

hashmap.put(character, itemstack1);
}

ItemStack[] aitemstack = new ItemStack[j * k];

for (int i1 = 0; i1 < j * k; ++i1)
{
char c0 = s.charAt(i1);

if (hashmap.containsKey(Character.valueOf(c0)))
{
aitemstack[i1] = ((ItemStack)hashmap.get(Character.valueOf(c0))).copy();
}
else
{
aitemstack[i1] = null;
}
}

MergingShapedRecipes shapedrecipes = new MergingShapedRecipes(j, k, aitemstack, par1ItemStack);
this.recipes.add(shapedrecipes);
return shapedrecipes;
}

public void addShapelessRecipe(ItemStack par1ItemStack, Object ... par2ArrayOfObj)
{
ArrayList arraylist = new ArrayList();
Object[] aobject = par2ArrayOfObj;
int i = par2ArrayOfObj.length;

for (int j = 0; j < i; ++j)
{
Object object1 = aobject[j];

if (object1 instanceof ItemStack)
{
arraylist.add(((ItemStack)object1).copy());
}
else if (object1 instanceof Item)
{
arraylist.add(new ItemStack((Item)object1));
}
else
{
if (!(object1 instanceof Block))
{
throw new RuntimeException("Invalid shapeless recipe!");
}

arraylist.add(new ItemStack((Block)object1));
}
}

this.recipes.add(new MergingShapelessRecipes(par1ItemStack, arraylist));
}

public ItemStack findMatchingRecipe(InventoryCrafting par1InventoryCrafting, World par2World)
{
int i = 0;
ItemStack itemstack = null;
ItemStack itemstack1 = null;
int j;

for (j = 0; j < par1InventoryCrafting.getSizeInventory(); ++j)
{
ItemStack itemstack2 = par1InventoryCrafting.getStackInSlot(j);

if (itemstack2 != null)
{
if (i == 0)
{
itemstack = itemstack2;
}

if (i == 1)
{
itemstack1 = itemstack2;
}

++i;
}
}

if (i == 4 && itemstack.itemID == itemstack1.itemID && itemstack.stackSize == 1 && itemstack1.stackSize == 1 && Item.itemsList[itemstack.itemID].isRepairable())
{
Item item = Item.itemsList[itemstack.itemID];
int k = item.getMaxDamage() - itemstack.getItemDamageForDisplay();
int l = item.getMaxDamage() - itemstack1.getItemDamageForDisplay();
int i1 = k + l + item.getMaxDamage() * 5 / 100;
int j1 = item.getMaxDamage() - i1;

if (j1 < 0)
{
j1 = 0;
}

return new ItemStack(itemstack.itemID, 1, j1);
}
else
{
for (j = 0; j < this.recipes.size(); ++j)
{
IRecipe irecipe = (IRecipe)this.recipes.get(j);

if (irecipe.matches(par1InventoryCrafting, par2World))
{
return irecipe.getCraftingResult(par1InventoryCrafting);
}
}

return null;
}
}

public List getRecipeList()
{
return this.recipes;
}
}

package CsFreakable.MiningPlus.crafting;

import java.util.Comparator;

import net.minecraft.item.crafting.IRecipe;
import net.minecraft.item.crafting.ShapedRecipes;
import net.minecraft.item.crafting.ShapelessRecipes;

public class RecipeSorterMergingTable implements Comparator
{
final CraftingManagerMergingTable craftingManager;

public RecipeSorterMergingTable(CraftingManagerMergingTable funcCraftingManager)
{
craftingManager = funcCraftingManager;
}

public int compareRecipes(IRecipe par1IRecipe, IRecipe par2IRecipe)
{
return par1IRecipe instanceof MergingShapelessRecipes && par2IRecipe instanceof MergingShapedRecipes ? 1 : (par2IRecipe instanceof MergingShapelessRecipes && par1IRecipe instanceof MergingShapedRecipes ? -1 : (par2IRecipe.getRecipeSize() < par1IRecipe.getRecipeSize() ? -1 : (par2IRecipe.getRecipeSize() > par1IRecipe.getRecipeSize() ? 1 : 0)));
}

public int compare(Object par1Obj, Object par2Obj)
{
return this.compareRecipes((IRecipe)par1Obj, (IRecipe)par2Obj);
}
}

package CsFreakable.MiningPlus.block.container;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCraftResult;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import net.minecraft.world.World;
import CsFreakable.MiningPlus.core.MP_Blocks;

public class ContainerMergingTable extends Container
{
public InventoryCrafting craftMatrix = new InventoryCrafting(this, 4, 4);
public IInventory craftResult = new InventoryCraftResult();
private World worldObj;
private int posX;
private int posY;
private int posZ;

public ContainerMergingTable(InventoryPlayer par1InventoryPlayer, World par2World, int par3, int par4, int par5)
{
this.worldObj = par2World;
this.posX = par3;
this.posY = par4;
this.posZ = par5;
this.addSlotToContainer(new SlotCrafting(par1InventoryPlayer.player, this.craftMatrix, this.craftResult, 0, 124, 35));
int l;
int i1;

for (l = 0; l < 3; ++l)
{
for (i1 = 0; i1 < 3; ++i1)
{
this.addSlotToContainer(new Slot(this.craftMatrix, i1 + l * 3, 30 + i1 * 18, 17 + l * 18));
}
}

for (l = 0; l < 3; ++l)
{
for (i1 = 0; i1 < 9; ++i1)
{
this.addSlotToContainer(new Slot(par1InventoryPlayer, i1 + l * 9 + 9, 8 + i1 * 18, 84 + l * 18));
}
}

for (l = 0; l < 9; ++l)
{
this.addSlotToContainer(new Slot(par1InventoryPlayer, l, 8 + l * 18, 142));
}

this.onCraftMatrixChanged(this.craftMatrix);
}

public void onCraftMatrixChanged(IInventory par1IInventory)
{
this.craftResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.worldObj));
}

public void onContainerClosed(EntityPlayer par1EntityPlayer)
{
super.onContainerClosed(par1EntityPlayer);

if (!this.worldObj.isRemote)
{
for (int i = 0; i < 16; ++i)
{
ItemStack itemstack = this.craftMatrix.getStackInSlotOnClosing(i);

if (itemstack != null)
{
par1EntityPlayer.dropPlayerItem(itemstack);
}
}
}
}

public boolean canInteractWith(EntityPlayer par1EntityPlayer)
{
return this.worldObj.getBlockId(this.posX, this.posY, this.posZ) != MP_Blocks.mergingTable.blockID ? false : par1EntityPlayer.getDistanceSq((double)this.posX + 0.5D, (double)this.posY + 0.5D, (double)this.posZ + 0.5D) <= 64.0D;
}

public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2)
{
ItemStack itemstack = null;
Slot slot = (Slot)this.inventorySlots.get(par2);

if (slot != null && slot.getHasStack())
{
ItemStack itemstack1 = slot.getStack();
itemstack = itemstack1.copy();

if (par2 == 0)
{
if (!this.mergeItemStack(itemstack1, 10, 46, true))
{
return null;
}

slot.onSlotChange(itemstack1, itemstack);
}
else if (par2 >= 10 && par2 < 37)
{
if (!this.mergeItemStack(itemstack1, 37, 46, false))
{
return null;
}
}
else if (par2 >= 37 && par2 < 46)
{
if (!this.mergeItemStack(itemstack1, 10, 37, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemstack1, 10, 46, false))
{
return null;
}

if (itemstack1.stackSize == 0)
{
slot.putStack((ItemStack)null);
}
else
{
slot.onSlotChanged();
}

if (itemstack1.stackSize == itemstack.stackSize)
{
return null;
}

slot.onPickupFromSlot(par1EntityPlayer, itemstack1);
}

return itemstack;
}

public boolean func_94530_a(ItemStack par1ItemStack, Slot par2Slot)
{
return par2Slot.inventory != this.craftResult && super.func_94530_a(par1ItemStack, par2Slot);
}
}

package CsFreakable.MiningPlus.crafting;

import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;

public class MergingShapedRecipes implements IRecipe
{
public final int recipeWidth;
public final int recipeHeight;
public final ItemStack[] recipeItems;
private ItemStack recipeOutput;
public final int recipeOutputItemID;
private boolean field_92101_f = false;

public MergingShapedRecipes(int par1, int par2, ItemStack[] par3ArrayOfItemStack, ItemStack par4ItemStack)
{
this.recipeOutputItemID = par4ItemStack.itemID;
this.recipeWidth = par1;
this.recipeHeight = par2;
this.recipeItems = par3ArrayOfItemStack;
this.recipeOutput = par4ItemStack;
}

public ItemStack getRecipeOutput()
{
return this.recipeOutput;
}

public boolean matches(InventoryCrafting par1InventoryCrafting, World par2World)
{
for (int i = 0; i <= 4 - this.recipeWidth; ++i)
{
for (int j = 0; j <= 4 - this.recipeHeight; ++j)
{
if (this.checkMatch(par1InventoryCrafting, i, j, true))
{
return true;
}

if (this.checkMatch(par1InventoryCrafting, i, j, false))
{
return true;
}
}
}

return false;
}

private boolean checkMatch(InventoryCrafting par1InventoryCrafting, int par2, int par3, boolean par4)
{
for (int k = 0; k < 4; ++k)
{
for (int l = 0; l < 4; ++l)
{
int i1 = k - par2;
int j1 = l - par3;
ItemStack itemstack = null;

if (i1 >= 0 && j1 >= 0 && i1 < this.recipeWidth && j1 < this.recipeHeight)
{
if (par4)
{
itemstack = this.recipeItems[this.recipeWidth - i1 - 1 + j1 * this.recipeWidth];
}
else
{
itemstack = this.recipeItems[i1 + j1 * this.recipeWidth];
}
}

ItemStack itemstack1 = par1InventoryCrafting.getStackInRowAndColumn(k, l);

if (itemstack1 != null || itemstack != null)
{
if (itemstack1 == null && itemstack != null || itemstack1 != null && itemstack == null)
{
return false;
}

if (itemstack.itemID != itemstack1.itemID)
{
return false;
}

if (itemstack.getItemDamage() != 32767 && itemstack.getItemDamage() != itemstack1.getItemDamage())
{
return false;
}
}
}
}

return true;
}

public ItemStack getCraftingResult(InventoryCrafting par1InventoryCrafting)
{
ItemStack itemstack = this.getRecipeOutput().copy();

if (this.field_92101_f)
{
for (int i = 0; i < par1InventoryCrafting.getSizeInventory(); ++i)
{
ItemStack itemstack1 = par1InventoryCrafting.getStackInSlot(i);

if (itemstack1 != null && itemstack1.hasTagCompound())
{
itemstack.setTagCompound((NBTTagCompound)itemstack1.stackTagCompound.copy());
}
}
}

return itemstack;
}

public int getRecipeSize()
{
return this.recipeWidth * this.recipeHeight;
}

public MergingShapedRecipes func_92100_c()
{
this.field_92101_f = true;
return this;
}
}

package CsFreakable.MiningPlus.crafting;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.IRecipe;
import net.minecraft.world.World;

public class MergingShapelessRecipes implements IRecipe
{
private final ItemStack recipeOutput;
public final List recipeItems;

public MergingShapelessRecipes(ItemStack par1ItemStack, List par2List)
{
this.recipeOutput = par1ItemStack;
this.recipeItems = par2List;
}

public ItemStack getRecipeOutput()
{
return this.recipeOutput;
}

public boolean matches(InventoryCrafting par1InventoryCrafting, World par2World)
{
ArrayList arraylist = new ArrayList(this.recipeItems);

for (int i = 0; i < 4; ++i)
{
for (int j = 0; j < 4; ++j)
{
ItemStack itemstack = par1InventoryCrafting.getStackInRowAndColumn(j, i);

if (itemstack != null)
{
boolean flag = false;
Iterator iterator = arraylist.iterator();

while (iterator.hasNext())
{
ItemStack itemstack1 = (ItemStack)iterator.next();

if (itemstack.itemID == itemstack1.itemID && (itemstack1.getItemDamage() == 32767 || itemstack.getItemDamage() == itemstack1.getItemDamage()))
{
flag = true;
arraylist.remove(itemstack1);
break;
}
}

if (!flag)
{
return false;
}
}
}
}

return arraylist.isEmpty();
}

public ItemStack getCraftingResult(InventoryCrafting par1InventoryCrafting)
{
return this.recipeOutput.copy();
}

public int getRecipeSize()
{
return this.recipeItems.size();
}
}