public ItemStack handle(EntityPlayer player, int mouseButton, Slot slot) {
    if (mouseButton > 0) {
      slot.putStack(null);
    } else if (mouseButton == 0) {
      ItemStack stack;
      InventoryPlayer playerInv = player.inventory;
      slot.onSlotChanged();
      ItemStack stackSlot = slot.getStack();
      ItemStack stackHeld = playerInv.getItemStack();

      if (stackSlot == null && stackHeld != null && slot.slotNumber != 22) {
        if (isItemValid(stackHeld)) {
          ItemStack copy = stackHeld.copy();
          copy.stackSize = 1;
          slot.putStack(copy);
        }
      }

      if (stackHeld == null) {
        if (tile instanceof TileFishSorter) {
          ((TileFishSorter) tile).swapSide(slot.slotNumber);
        }
      }
    }

    return null;
  }
 private ItemStack slotClickPhantom(
     Slot slot, int mouseButton, int modifier, EntityPlayer player) {
   ItemStack stack = null;
   if (mouseButton == 2) {
     if (((IPhantomSlot) slot).canAdjust()) slot.putStack(null);
   } else if (mouseButton == 0 || mouseButton == 1) {
     InventoryPlayer playerInv = player.inventory;
     slot.onSlotChanged();
     ItemStack stackSlot = slot.getStack();
     ItemStack stackHeld = playerInv.getItemStack();
     if (stackSlot != null) stack = stackSlot.copy();
     if (stackSlot == null) {
       if (stackHeld != null && slot.isItemValid(stackHeld))
         fillPhantomSlot(slot, stackHeld, mouseButton);
     } else if (stackHeld == null) {
       adjustPhantomSlot(slot, mouseButton, modifier);
       slot.onPickupFromSlot(player, playerInv.getItemStack());
     } else if (slot.isItemValid(stackHeld)) {
       if (ItemUtil.canStacksMerge(stackSlot, stackHeld))
         adjustPhantomSlot(slot, mouseButton, modifier);
       else fillPhantomSlot(slot, stackHeld, mouseButton);
     }
   }
   return stack;
 }
  @Override
  public ItemStack slotClick(int id, int button, ClickType clickType, EntityPlayer player) {
    Slot slot = id < 0 ? null : this.inventorySlots.get(id);
    if (!(slot instanceof IESlot.Ghost)) return super.slotClick(id, button, clickType, player);
    // Spooky Ghost Slots!!!!
    ItemStack stack = null;
    ItemStack stackSlot = slot.getStack();
    if (stackSlot != null) stack = stackSlot.copy();

    if (button == 2) slot.putStack(null);
    else if (button == 0 || button == 1) {
      InventoryPlayer playerInv = player.inventory;
      ItemStack stackHeld = playerInv.getItemStack();
      if (stackSlot == null) {
        if (stackHeld != null && slot.isItemValid(stackHeld)) {
          slot.putStack(Utils.copyStackWithAmount(stackHeld, 1));
        }
      } else if (stackHeld == null) {
        slot.putStack(null);
      } else if (slot.isItemValid(stackHeld)) {
        slot.putStack(Utils.copyStackWithAmount(stackHeld, 1));
      }
    } else if (button == 5) {
      InventoryPlayer playerInv = player.inventory;
      ItemStack stackHeld = playerInv.getItemStack();
      if (!slot.getHasStack()) {
        slot.putStack(Utils.copyStackWithAmount(stackHeld, 1));
      }
    }
    return stack;
  }
  /**
   * @author blood - May 13th, 2016
   * @reason SpongeForge requires an overwrite so we do it here instead.
   */
  @Overwrite
  public EntityItem dropOneItem(boolean dropAll) {
    if (this.worldObj.isRemote) {
      return this.dropItem(
          this.inventory.decrStackSize(
              this.inventory.currentItem,
              dropAll && this.inventory.getCurrentItem() != null
                  ? this.inventory.getCurrentItem().stackSize
                  : 1),
          false,
          true);
    }

    ItemStack stack = inventory.getCurrentItem();

    if (stack == null) {
      return null;
    }

    if (SpongeImplHooks.onDroppedByPlayer(stack.getItem(), stack, (EntityPlayer) (Object) this)) {
      int count =
          dropAll && this.inventory.getCurrentItem() != null
              ? this.inventory.getCurrentItem().stackSize
              : 1;
      return SpongeImplHooks.onPlayerToss(
          (EntityPlayer) (Object) this,
          inventory.decrStackSize(inventory.currentItem, count),
          true);
    }

    return null;
  }
  @Override
  public HashMap<Integer, ItemStack> addItem(ItemStack... items) {
    HashMap<Integer, ItemStack> leftover = new HashMap<Integer, ItemStack>();

    InventoryPlayer inv = (InventoryPlayer) inventory;
    int count = 0;
    for (ItemStack i : items) {
      net.minecraft.item.ItemStack internal = BukkitItemStack.createNMSItemStack(i);
      if (!inv.addItemStackToInventory(internal)) {
        int origsize = internal.stackSize;
        internal.stackSize--;

        while (!inv.addItemStackToInventory(internal)) {
          internal.stackSize--;
          if (internal.stackSize == 0) {
            break;
          }
        }

        leftover.put(
            count,
            new BukkitItemStack(
                internal.itemID, origsize - internal.stackSize, (short) internal.getItemDamage()));
      }
      count++;
    }
    return leftover;
  }
  /** Callback for when the crafting gui is closed. */
  public void onCraftGuiClosed(EntityPlayer par1EntityPlayer) {
    InventoryPlayer var2 = par1EntityPlayer.inventory;

    if (var2.getItemStack() != null) {
      par1EntityPlayer.dropPlayerItem(var2.getItemStack());
      var2.setItemStack((ItemStack) null);
    }
  }
 public void refreshState() {
   hasValidItem =
       (inventory.getStackInSlot(slot) != null
           && ((inventory.getStackInSlot(slot).getItem() instanceof IConfigurableItem
                   && !((IConfigurableItem) inventory.getStackInSlot(slot).getItem())
                       .getFields(inventory.getStackInSlot(slot), slot)
                       .isEmpty())
               || inventory.getStackInSlot(slot).getItem() instanceof IInventoryTool));
 }
  @Override
  public void renderBackground(
      Minecraft minecraft, int offsetX, int offsetY, int mouseX, int mouseY) {
    Minecraft.getMinecraft().renderEngine.bindTexture(texture);
    int heightOffset = isMouseOver(mouseX, mouseY) ? 36 : 18;
    if (!hasValidItem) drawTexturedModalRect(x, y, 0, 0, getWidth(), getHeight());
    else drawTexturedModalRect(x, y, 0, heightOffset, getWidth(), getHeight());

    if (inventory.getStackInSlot(slot) != null) {
      drawItemStack(inventory.getStackInSlot(slot), x + 1, y + 1, "null");
    }
  }
 @Override
 public void renderFinal(Minecraft minecraft, int offsetX, int offsetY, int mouseX, int mouseY) {
   if (isMouseOver(mouseX, mouseY) && hasValidItem) {
     List<String> list = new ArrayList<String>();
     List<ItemConfigField> fields =
         ((IConfigurableItem) inventory.getStackInSlot(slot).getItem())
             .getFields(inventory.getStackInSlot(slot), slot);
     for (ItemConfigField field : fields) {
       list.add(field.getLocalizedName() + ": " + field.getFormatedValue());
     }
     drawHoveringText(list, mouseX + offsetX, mouseY + offsetY + 10, fontRendererObj);
   }
 }
  public ArmorExtendedContainer(InventoryPlayer inventoryplayer, ArmorExtended armor) {
    invPlayer = inventoryplayer;
    this.armor = armor;

    this.addSlotToContainer(new SlotAccessory(armor, 0, 80, 17));
    this.addSlotToContainer(new SlotAccessory(armor, 1, 80, 35));
    this.addSlotToContainer(new SlotAccessory(armor, 2, 116, 17));
    this.addSlotToContainer(new SlotAccessory(armor, 3, 116, 35));
    this.addSlotToContainer(new SlotAccessory(armor, 4, 152, 53));
    this.addSlotToContainer(new SlotAccessory(armor, 5, 152, 35));
    this.addSlotToContainer(new SlotAccessory(armor, 6, 152, 17));
    for (int playerArmor = 0; playerArmor < 4; ++playerArmor) {
      this.addSlotToContainer(
          new SlotArmorCopy(
              this,
              inventoryplayer,
              inventoryplayer.getSizeInventory() - 1 - playerArmor,
              98,
              8 + playerArmor * 18,
              playerArmor));
    }

    for (int column = 0; column < 3; column++) {
      for (int row = 0; row < 9; row++) {
        this.addSlotToContainer(
            new Slot(inventoryplayer, row + column * 9 + 9, 8 + row * 18, 84 + column * 18));
      }
    }

    for (int column = 0; column < 9; column++) {
      this.addSlotToContainer(new Slot(inventoryplayer, column, 8 + column * 18, 142));
    }
  }
 private boolean swapToItem(InventoryPlayer inventory, int itemID) {
   int slot = getInventorySlotWithItem(inventory, itemID);
   if (slot > -1 && slot < 9) {
     inventory.currentItem = slot;
     return true;
   }
   return false;
 }
  public ContainerPlayer(
      final InventoryPlayer par1InventoryPlayer, boolean par2, EntityPlayer par3EntityPlayer) {
    this.isLocalWorld = par2;
    this.thePlayer = par3EntityPlayer;
    this.addSlotToContainer(
        new SlotCrafting(
            par1InventoryPlayer.player, this.craftMatrix, this.craftResult, 0, 144, 36));
    int i;
    int j;

    for (i = 0; i < 2; ++i) {
      for (j = 0; j < 2; ++j) {
        this.addSlotToContainer(new Slot(this.craftMatrix, j + i * 2, 88 + j * 18, 26 + i * 18));
      }
    }

    for (i = 0; i < 4; ++i) {
      final int k = i;
      this.addSlotToContainer(
          new Slot(
              par1InventoryPlayer, par1InventoryPlayer.getSizeInventory() - 1 - i, 8, 8 + i * 18) {
            private static final String __OBFID = "CL_00001755";
            /**
             * Returns the maximum stack size for a given slot (usually the same as
             * getInventoryStackLimit(), but 1 in the case of armor slots)
             */
            public int getSlotStackLimit() {
              return 1;
            }
            /**
             * Check if the stack is a valid item for this slot. Always true beside for the armor
             * slots.
             */
            public boolean isItemValid(ItemStack par1ItemStack) {
              if (par1ItemStack == null) return false;
              return par1ItemStack.getItem().isValidArmor(par1ItemStack, k, thePlayer);
            }
            /** Returns the icon index on items.png that is used as background image of the slot. */
            @SideOnly(Side.CLIENT)
            public IIcon getBackgroundIconIndex() {
              return ItemArmor.func_94602_b(k);
            }
          });
    }

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

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

    this.onCraftMatrixChanged(this.craftMatrix);
  }
  public ContainerPlayer(
      final InventoryPlayer par1InventoryPlayer, boolean par2, EntityPlayer par3EntityPlayer) {
    this.isLocalWorld = par2;
    this.thePlayer = par3EntityPlayer;
    this.addSlotToContainer(
        new SlotCrafting(
            par1InventoryPlayer.player, this.craftMatrix, this.craftResult, 0, 144, 36));
    int var4;
    int var5;

    for (var4 = 0; var4 < 2; ++var4) {
      for (var5 = 0; var5 < 2; ++var5) {
        this.addSlotToContainer(
            new Slot(this.craftMatrix, var5 + var4 * 2, 88 + var5 * 18, 26 + var4 * 18));
      }
    }

    for (var4 = 0; var4 < 4; ++var4) {
      final int var44 = var4;
      this.addSlotToContainer(
          new Slot(
              par1InventoryPlayer,
              par1InventoryPlayer.getSizeInventory() - 1 - var4,
              8,
              8 + var4 * 18) {
            private static final String __OBFID = "CL_00001755";

            public int getSlotStackLimit() {
              return 1;
            }

            public boolean isItemValid(ItemStack par1ItemStack) {
              return par1ItemStack == null
                  ? false
                  : (par1ItemStack.getItem() instanceof ItemArmor
                      ? ((ItemArmor) par1ItemStack.getItem()).armorType == var44
                      : (par1ItemStack.getItem() != Item.getItemFromBlock(Blocks.pumpkin)
                              && par1ItemStack.getItem() != Items.skull
                          ? false
                          : var44 == 0));
            }
          });
    }

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

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

    this.onCraftMatrixChanged(this.craftMatrix);
  }
 /**
  * Draw the foreground layer for the GuiContainer (everything in front of the items). Args :
  * mouseX, mouseY
  */
 @Override
 protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
   fontRendererObj.drawString(
       field_175380_I == null ? I18n.format("container.enchant", new Object[0]) : field_175380_I,
       12,
       5,
       4210752);
   fontRendererObj.drawString(
       I18n.format(field_175379_F.getInventoryName(), new Object[0]), 8, ySize - 96 + 2, 4210752);
 }
  public ContainerPlayer(final InventoryPlayer playerInventory, boolean localWorld, Player player) {
    this.isLocalWorld = localWorld;
    this.thePlayer = player;
    this.addSlotToContainer(
        new SlotCrafting(playerInventory.player, this.craftMatrix, this.craftResult, 0, 144, 36));

    for (int i = 0; i < 2; ++i) {
      for (int j = 0; j < 2; ++j) {
        this.addSlotToContainer(new Slot(this.craftMatrix, j + i * 2, 88 + j * 18, 26 + i * 18));
      }
    }

    for (int k = 0; k < 4; ++k) {
      final int k_f = k;
      this.addSlotToContainer(
          new Slot(playerInventory, playerInventory.getSizeInventory() - 1 - k, 8, 8 + k * 18) {
            public int getSlotStackLimit() {
              return 1;
            }

            public boolean isItemValid(ItemStack stack) {
              return stack == null
                  ? false
                  : (stack.getItem() instanceof ItemArmor
                      ? ((ItemArmor) stack.getItem()).armorType == k_f
                      : (stack.getItem() != Item.getItemFromBlock(Blocks.pumpkin)
                              && stack.getItem() != Items.skull
                          ? false
                          : k_f == 0));
            }
          });
    }

    for (int l = 0; l < 3; ++l) {
      for (int j1 = 0; j1 < 9; ++j1) {
        this.addSlotToContainer(
            new Slot(playerInventory, j1 + (l + 1) * 9, 8 + j1 * 18, 84 + l * 18));
      }
    }

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

    this.onCraftMatrixChanged(this.craftMatrix);
  }
Exemple #16
0
 public void buyGun(int i, InventoryPlayer inventory, GunBoxType type) {
   if (FMLCommonHandler.instance().getEffectiveSide().isClient()) {
     FlansMod.proxy.buyGun(type, i);
   }
   if (i <= type.numGuns && type.guns[i] != null) {
     boolean canBuy = true;
     for (ItemStack check : type.gunParts[i]) {
       int numMatchingStuff = 0;
       for (int j = 0; j < inventory.getSizeInventory(); j++) {
         ItemStack stack = inventory.getStackInSlot(j);
         if (stack != null
             && stack.itemID == check.itemID
             && stack.getItemDamage() == check.getItemDamage()) {
           numMatchingStuff += stack.stackSize;
         }
       }
       if (numMatchingStuff < check.stackSize) {
         canBuy = false;
       }
     }
     if (canBuy) {
       for (ItemStack remove : type.gunParts[i]) {
         int amountLeft = remove.stackSize;
         for (int j = 0; j < inventory.getSizeInventory(); j++) {
           ItemStack stack = inventory.getStackInSlot(j);
           if (amountLeft > 0
               && stack != null
               && stack.itemID == remove.itemID
               && stack.getItemDamage() == remove.getItemDamage()) {
             amountLeft -= inventory.decrStackSize(j, amountLeft).stackSize;
           }
         }
       }
       if (!inventory.addItemStackToInventory(new ItemStack(type.guns[i].getItem()))) {
         // Drop gun on floor
       }
     } else {
       // Cant buy
       // TODO : Add flashing red squares around the items you lack
     }
   }
 }
 @Override
 public void setItemInHand(ItemStack stack) {
   realInv.setInventorySlotContents(getHeldItemSlot(), BukkitItemStack.createNMSItemStack(stack));
 }
  public ItemStack slotClick(int par1, int par2, int par3, EntityPlayer par4EntityPlayer) {
    ItemStack var5 = null;
    InventoryPlayer var6 = par4EntityPlayer.inventory;
    Slot var7;
    ItemStack var8;
    int var10;
    ItemStack var11;

    if ((par3 == 0 || par3 == 1) && (par2 == 0 || par2 == 1)) {
      if (par1 == -999) {
        if (var6.getItemStack() != null && par1 == -999) {
          if (par2 == 0) {
            par4EntityPlayer.dropPlayerItem(var6.getItemStack());
            var6.setItemStack((ItemStack) null);
          }

          if (par2 == 1) {
            // CraftBukkit start - store a reference
            ItemStack itemstack3 = var6.getItemStack();
            par4EntityPlayer.dropPlayerItem(itemstack3.splitStack(1));

            if (itemstack3.stackSize == 0) {
              // CraftBukkit end
              var6.setItemStack((ItemStack) null);
            }
          }
        }
      } else if (par3 == 1) {
        var7 = (Slot) this.inventorySlots.get(par1);

        if (var7 != null && var7.canTakeStack(par4EntityPlayer)) {
          var8 = this.transferStackInSlot(par4EntityPlayer, par1);

          if (var8 != null) {
            int var12 = var8.itemID;
            var5 = var8.copy();

            if (var7 != null && var7.getStack() != null && var7.getStack().itemID == var12) {
              this.retrySlotClick(par1, par2, true, par4EntityPlayer);
            }
          }
        }
      } else {
        if (par1 < 0) {
          return null;
        }

        var7 = (Slot) this.inventorySlots.get(par1);

        if (var7 != null) {
          var8 = var7.getStack();
          ItemStack var13 = var6.getItemStack();

          if (var8 != null) {
            var5 = var8.copy();
          }

          if (var8 == null) {
            if (var13 != null && var7.isItemValid(var13)) {
              var10 = par2 == 0 ? var13.stackSize : 1;

              if (var10 > var7.getSlotStackLimit()) {
                var10 = var7.getSlotStackLimit();
              }

              if (var13.stackSize >= var10) // CraftBukkit
              var7.putStack(var13.splitStack(var10));

              if (var13.stackSize == 0) {
                var6.setItemStack((ItemStack) null);
              }
            }
          } else if (var7.canTakeStack(par4EntityPlayer)) {
            if (var13 == null) {
              var10 = par2 == 0 ? var8.stackSize : (var8.stackSize + 1) / 2;
              var11 = var7.decrStackSize(var10);
              var6.setItemStack(var11);

              if (var8.stackSize == 0) {
                var7.putStack((ItemStack) null);
              }

              var7.onPickupFromSlot(par4EntityPlayer, var6.getItemStack());
            } else if (var7.isItemValid(var13)) {
              if (var8.itemID == var13.itemID
                  && var8.getItemDamage() == var13.getItemDamage()
                  && ItemStack.areItemStackTagsEqual(var8, var13)) {
                var10 = par2 == 0 ? var13.stackSize : 1;

                if (var10 > var7.getSlotStackLimit() - var8.stackSize) {
                  var10 = var7.getSlotStackLimit() - var8.stackSize;
                }

                if (var10 > var13.getMaxStackSize() - var8.stackSize) {
                  var10 = var13.getMaxStackSize() - var8.stackSize;
                }

                var13.splitStack(var10);

                if (var13.stackSize == 0) {
                  var6.setItemStack((ItemStack) null);
                }

                var8.stackSize += var10;
              } else if (var13.stackSize <= var7.getSlotStackLimit()) {
                var7.putStack(var13);
                var6.setItemStack(var8);
              }
            } else if (var8.itemID == var13.itemID
                && var13.getMaxStackSize() > 1
                && (!var8.getHasSubtypes() || var8.getItemDamage() == var13.getItemDamage())
                && ItemStack.areItemStackTagsEqual(var8, var13)) {
              var10 = var8.stackSize;

              if (var10 > 0 && var10 + var13.stackSize <= var13.getMaxStackSize()) {
                var13.stackSize += var10;
                var8 = var7.decrStackSize(var10);

                if (var8.stackSize == 0) {
                  var7.putStack((ItemStack) null);
                }

                var7.onPickupFromSlot(par4EntityPlayer, var6.getItemStack());
              }
            }
          }

          var7.onSlotChanged();
        }
      }
    } else if (par3 == 2 && par2 >= 0 && par2 < 9) {
      var7 = (Slot) this.inventorySlots.get(par1);

      if (var7.canTakeStack(par4EntityPlayer)) {
        var8 = var6.getStackInSlot(par2);
        boolean var9 = var8 == null || var7.inventory == var6 && var7.isItemValid(var8);
        var10 = -1;

        if (!var9) {
          var10 = var6.getFirstEmptyStack();
          var9 |= var10 > -1;
        }

        if (var7.getHasStack() && var9) {
          var11 = var7.getStack();
          var6.setInventorySlotContents(par2, var11);

          if ((var7.inventory != var6 || !var7.isItemValid(var8)) && var8 != null) {
            if (var10 > -1) {
              var6.addItemStackToInventory(var8);
              var7.decrStackSize(var11.stackSize);
              var7.putStack((ItemStack) null);
              var7.onPickupFromSlot(par4EntityPlayer, var11);
            }
          } else {
            var7.decrStackSize(var11.stackSize);
            var7.putStack(var8);
            var7.onPickupFromSlot(par4EntityPlayer, var11);
          }
        } else if (!var7.getHasStack() && var8 != null && var7.isItemValid(var8)) {
          var6.setInventorySlotContents(par2, (ItemStack) null);
          var7.putStack(var8);
        }
      }
    } else if (par3 == 3
        && par4EntityPlayer.capabilities.isCreativeMode
        && var6.getItemStack() == null
        && par1 >= 0) {
      var7 = (Slot) this.inventorySlots.get(par1);

      if (var7 != null && var7.getHasStack()) {
        var8 = var7.getStack().copy();
        var8.stackSize = var8.getMaxStackSize();
        var6.setItemStack(var8);
      }
    }

    return var5;
  }
  public ContainerTravellersInv(InventoryPlayer invPlayer) {
    this.player = invPlayer.player;
    this.invTG = new InventoryTG(this, player);
    if (!player.worldObj.isRemote)
      this.invTG.stackList = TravellersGearAPI.getExtendedInventory(player);
    this.invBaubles = ModCompatability.getNewBaublesInv(player);
    ModCompatability.setBaubleContainer(invBaubles, this);
    if (!player.worldObj.isRemote)
      ModCompatability.setBaubleInvStacklist(invBaubles, BaublesApi.getBaubles(player));

    crafting =
        addSlot(new SlotCrafting(invPlayer.player, this.craftMatrix, this.craftResult, 0, 144, 36));
    int i;
    int j;
    for (i = 0; i < 2; ++i) {
      for (j = 0; j < 2; ++j) {
        this.addSlot(new Slot(this.craftMatrix, j + i * 2, 106 + j * 18, 26 + i * 18));
      }
    }
    nonInventorySlots = 0 + (crafting >= 0 ? 5 : 0);

    vanillaArmor[0] =
        addSlot(
            new SlotRestricted(
                invPlayer,
                invPlayer.getSizeInventory() - 1 - 0,
                6,
                26,
                player,
                SlotRestricted.SlotType.VANILLA_HELM));
    vanillaArmor[1] =
        addSlot(
            new SlotRestricted(
                invPlayer,
                invPlayer.getSizeInventory() - 1 - 1,
                6,
                44,
                player,
                SlotRestricted.SlotType.VANILLA_CHEST));
    vanillaArmor[2] =
        addSlot(
            new SlotRestricted(
                invPlayer,
                invPlayer.getSizeInventory() - 1 - 2,
                6,
                62,
                player,
                SlotRestricted.SlotType.VANILLA_LEGS));
    vanillaArmor[3] =
        addSlot(
            new SlotRestricted(
                invPlayer,
                invPlayer.getSizeInventory() - 1 - 3,
                6,
                80,
                player,
                SlotRestricted.SlotType.VANILLA_BOOTS));
    nonInventorySlots +=
        (vanillaArmor[0] >= 0 ? 1 : 0)
            + (vanillaArmor[1] >= 0 ? 1 : 0)
            + (vanillaArmor[2] >= 0 ? 1 : 0)
            + (vanillaArmor[3] >= 0 ? 1 : 0);

    travGear[0] =
        addSlot(
            new SlotRestricted(this.invTG, 0, 42, 8, player, SlotRestricted.SlotType.TRAVEL_CLOAK));
    travGear[1] =
        addSlot(
            new SlotRestricted(
                this.invTG, 1, 78, 26, player, SlotRestricted.SlotType.TRAVEL_SHOULDER));
    travGear[2] =
        addSlot(
            new SlotRestricted(
                this.invTG, 2, 78, 62, player, SlotRestricted.SlotType.TRAVEL_VAMBRACE));
    travGear[3] =
        addSlot(
            new SlotRestricted(this.invTG, 3, 6, 98, player, SlotRestricted.SlotType.TRAVEL_TITLE));
    nonInventorySlots +=
        (travGear[0] >= 0 ? 1 : 0)
            + (travGear[1] >= 0 ? 1 : 0)
            + (travGear[2] >= 0 ? 1 : 0)
            + (travGear[3] >= 0 ? 1 : 0);

    if (TravellersGear.BAUBLES && invBaubles != null) {
      baubles[0] =
          addSlot(
              new SlotRestricted(
                  this.invBaubles, 0, 24, 8, player, SlotRestricted.SlotType.BAUBLE_NECK));
      baubles[1] =
          addSlot(
              new SlotRestricted(
                  this.invBaubles, 1, 24, 98, player, SlotRestricted.SlotType.BAUBLE_RING));
      baubles[2] =
          addSlot(
              new SlotRestricted(
                  this.invBaubles, 2, 42, 98, player, SlotRestricted.SlotType.BAUBLE_RING));
      baubles[3] =
          addSlot(
              new SlotRestricted(
                  this.invBaubles, 3, 78, 44, player, SlotRestricted.SlotType.BAUBLE_BELT));
      nonInventorySlots +=
          (baubles[0] >= 0 ? 1 : 0)
              + (baubles[1] >= 0 ? 1 : 0)
              + (baubles[2] >= 0 ? 1 : 0)
              + (baubles[3] >= 0 ? 1 : 0);
    }

    this.invMari = ModCompatability.getMariInventory(player);
    if (TravellersGear.MARI && invMari != null) {
      mari[0] =
          addSlot(
              new SlotRestricted(
                  this.invMari, 0, 60, 98, player, SlotRestricted.SlotType.MARI_RING));
      mari[1] =
          addSlot(
              new SlotRestricted(
                  this.invMari, 1, 78, 80, player, SlotRestricted.SlotType.MARI_BRACELET));
      mari[2] =
          addSlot(
              new SlotRestricted(
                  this.invMari, 2, 60, 8, player, SlotRestricted.SlotType.MARI_NECKLACE));
      nonInventorySlots += (mari[0] >= 0 ? 1 : 0) + (mari[1] >= 0 ? 1 : 0) + (mari[2] >= 0 ? 1 : 0);
    }

    this.invTConArmor = ModCompatability.getTConArmorInv(player);
    if (TravellersGear.TCON && invTConArmor != null) {
      tcon[0] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 1, 78, 98, player, SlotRestricted.SlotType.TINKERS_GLOVE));
      tcon[1] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 2, 78, 8, player, SlotRestricted.SlotType.TINKERS_BAG));
      tcon[2] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 6, 191, 31, player, SlotRestricted.SlotType.TINKERS_HEART_R));
      tcon[3] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 5, 191, 49, player, SlotRestricted.SlotType.TINKERS_HEART_Y));
      tcon[4] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 4, 191, 67, player, SlotRestricted.SlotType.TINKERS_HEART_G));
      //			tcon[5]=addSlot(new SlotRestricted(this.invTConArmor, 3, 6, 31, player,
      // SlotRestricted.SlotType.TINKERS_BELT));// (doesn't work)
      tcon[5] =
          addSlot(
              new SlotRestricted(
                  this.invTConArmor, 0, 6, 31, player, SlotRestricted.SlotType.TINKERS_MASK));
      nonInventorySlots +=
          (tcon[0] >= 0 ? 1 : 0)
              + (tcon[1] >= 0 ? 1 : 0)
              + (tcon[2] >= 0 ? 1 : 0)
              + (tcon[3] >= 0 ? 1 : 0)
              + (tcon[4] >= 0 ? 1 : 0)
              + (tcon[5] >= 0 ? 1 : 0);
    }
    // PLAYER INVENTORY
    playerInventorySlots = 0;
    playerHotbarSlots = 0;
    for (i = 0; i < 3; ++i)
      for (j = 0; j < 9; ++j)
        if (this.addSlot(
                new Slot(invPlayer, j + (i + 1) * 9, 6 + j * 18 + (j > 4 ? 10 : 0), 119 + i * 18))
            >= 0) playerInventorySlots++;
    for (i = 0; i < 9; ++i)
      if (this.addSlot(new Slot(invPlayer, i, 6 + i * 18 + (i > 4 ? 10 : 0), 173)) >= 0)
        playerHotbarSlots++;

    this.onCraftMatrixChanged(this.craftMatrix);
  }
  public void func_73863_a(int p_73863_1_, int p_73863_2_, float p_73863_3_) {
    this.func_73873_v_();
    int var4 = this.field_74198_m;
    int var5 = this.field_74197_n;
    this.func_74185_a(p_73863_3_, p_73863_1_, p_73863_2_);
    GL11.glDisable('\u803a');
    RenderHelper.func_74518_a();
    GL11.glDisable(2896);
    GL11.glDisable(2929);
    super.func_73863_a(p_73863_1_, p_73863_2_, p_73863_3_);
    RenderHelper.func_74520_c();
    GL11.glPushMatrix();
    GL11.glTranslatef((float) var4, (float) var5, 0.0F);
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    GL11.glEnable('\u803a');
    this.field_82320_o = null;
    short var6 = 240;
    short var7 = 240;
    OpenGlHelper.func_77475_a(OpenGlHelper.field_77476_b, (float) var6 / 1.0F, (float) var7 / 1.0F);
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);

    int var9;
    for (int var13 = 0; var13 < this.field_74193_d.field_75151_b.size(); ++var13) {
      Slot var14 = (Slot) this.field_74193_d.field_75151_b.get(var13);
      this.func_74192_a(var14);
      if (this.func_74186_a(var14, p_73863_1_, p_73863_2_)) {
        this.field_82320_o = var14;
        GL11.glDisable(2896);
        GL11.glDisable(2929);
        int var8 = var14.field_75223_e;
        var9 = var14.field_75221_f;
        this.func_73733_a(var8, var9, var8 + 16, var9 + 16, -2130706433, -2130706433);
        GL11.glEnable(2896);
        GL11.glEnable(2929);
      }
    }

    this.func_74189_g(p_73863_1_, p_73863_2_);
    InventoryPlayer var15 = this.field_73882_e.field_71439_g.field_71071_by;
    ItemStack var16 = this.field_85050_q == null ? var15.func_70445_o() : this.field_85050_q;
    if (var16 != null) {
      byte var18 = 8;
      var9 = this.field_85050_q == null ? 8 : 16;
      if (this.field_85050_q != null && this.field_90018_r) {
        var16 = var16.func_77946_l();
        var16.field_77994_a = MathHelper.func_76123_f((float) var16.field_77994_a / 2.0F);
      }

      this.func_85044_b(var16, p_73863_1_ - var4 - var18, p_73863_2_ - var5 - var9);
    }

    if (this.field_85045_v != null) {
      float var17 = (float) (Minecraft.func_71386_F() - this.field_85046_u) / 100.0F;
      if (var17 >= 1.0F) {
        var17 = 1.0F;
        this.field_85045_v = null;
      }

      var9 = this.field_85047_t.field_75223_e - this.field_85049_r;
      int var10 = this.field_85047_t.field_75221_f - this.field_85048_s;
      int var11 = this.field_85049_r + (int) ((float) var9 * var17);
      int var12 = this.field_85048_s + (int) ((float) var10 * var17);
      this.func_85044_b(this.field_85045_v, var11, var12);
    }

    if (var15.func_70445_o() == null
        && this.field_82320_o != null
        && this.field_82320_o.func_75216_d()) {
      ItemStack var19 = this.field_82320_o.func_75211_c();
      this.func_74184_a(var19, p_73863_1_ - var4 + 8, p_73863_2_ - var5 + 8);
    }

    GL11.glPopMatrix();
    GL11.glEnable(2896);
    GL11.glEnable(2929);
    RenderHelper.func_74519_b();
  }
public final class BattlegearClientEvents implements IResourceManagerReloadListener {

  private final BattlegearInGameGUI inGameGUI;
  public final QuiverModel quiverModel;
  public final ResourceLocation quiverDetails;
  public final ResourceLocation quiverBase;
  // public static final ResourceLocation patterns = new ResourceLocation("battlegear2",
  // "textures/heraldry/Patterns-small.png");
  // public static int storageIndex;

  private static final int MAIN_INV = InventoryPlayer.getHotbarSize();
  public static final GuiPlaceableButton[] tabsList = {
    new GuiBGInventoryButton(0), new GuiSigilButton(1)
  };
  public static final BattlegearClientEvents INSTANCE = new BattlegearClientEvents();
  private String[] attributeNames;

  private BattlegearClientEvents() {
    inGameGUI = new BattlegearInGameGUI();
    quiverModel = new QuiverModel();
    quiverDetails =
        new ResourceLocation("battlegear2", "textures/armours/quiver/QuiverDetails.png");
    quiverBase = new ResourceLocation("battlegear2", "textures/armours/quiver/QuiverBase.png");
    ((IReloadableResourceManager) FMLClientHandler.instance().getClient().getResourceManager())
        .registerReloadListener(this);
  }

  /** Offset battle slots rendering according to config values */
  @SubscribeEvent(priority = EventPriority.HIGHEST)
  public void postRenderBar(RenderItemBarEvent.BattleSlots event) {
    if (!event.isMainHand) {
      event.xOffset += BattlegearConfig.battleBarOffset[0];
      event.yOffset += BattlegearConfig.battleBarOffset[1];
    } else {
      event.xOffset += BattlegearConfig.battleBarOffset[2];
      event.yOffset += BattlegearConfig.battleBarOffset[3];
    }
  }

  /** Offset quiver slots rendering according to config values */
  @SubscribeEvent(priority = EventPriority.HIGHEST)
  public void postRenderQuiver(RenderItemBarEvent.QuiverSlots event) {
    event.xOffset += BattlegearConfig.quiverBarOffset[0];
    event.yOffset += BattlegearConfig.quiverBarOffset[1];
  }

  /** Offset shield stamina rendering according to config values */
  @SubscribeEvent(priority = EventPriority.HIGHEST)
  public void postRenderShield(RenderItemBarEvent.ShieldBar event) {
    event.xOffset += BattlegearConfig.shieldBarOffset[0];
    event.yOffset += BattlegearConfig.shieldBarOffset[1];
  }

  /** Render all the Battlegear HUD elements */
  @SubscribeEvent(receiveCanceled = true)
  public void postRenderOverlay(RenderGameOverlayEvent.Post event) {
    if (event.type == RenderGameOverlayEvent.ElementType.HOTBAR
        && (BattlegearConfig.forceHUD || !event.isCanceled())) {
      inGameGUI.renderGameOverlay(event.partialTicks);
    }
  }

  /**
   * Bend the models when the item in left hand is used And stop the right hand inappropriate
   * bending
   */
  @SubscribeEvent(priority = EventPriority.LOW)
  public void renderPlayerLeftItemUsage(RenderLivingEvent.Pre event) {
    if (event.entity instanceof EntityPlayer) {
      EntityPlayer entityPlayer = (EntityPlayer) event.entity;
      ItemStack offhand =
          ((InventoryPlayerBattle) entityPlayer.inventory).getCurrentOffhandWeapon();
      if (offhand != null && event.renderer instanceof RenderPlayer) {
        ModelPlayer renderer = ((RenderPlayer) event.renderer).getPlayerModel();
        renderer.heldItemLeft = 1;
        if (entityPlayer.getItemInUseCount() > 0 && entityPlayer.getItemInUse() == offhand) {
          EnumAction enumaction = offhand.getItemUseAction();
          if (enumaction == EnumAction.BLOCK) {
            renderer.heldItemLeft = 3;
          } else if (enumaction == EnumAction.BOW) {
            renderer.aimedBow = true;
          }
          ItemStack mainhand = entityPlayer.inventory.getCurrentItem();
          renderer.heldItemRight = mainhand != null ? 1 : 0;
        } else if (((IBattlePlayer) entityPlayer).isBlockingWithShield()) {
          renderer.heldItemLeft = 3;
        }
      }
    }
  }

  /** Reset models to default values */
  @SubscribeEvent(priority = EventPriority.LOW)
  public void resetPlayerLeftHand(RenderPlayerEvent.Post event) {
    event.renderer.getPlayerModel().heldItemLeft = 0;
  }

  private static final int SKELETON_ARROW = 5;
  /** Render quiver on skeletons if possible */
  @SubscribeEvent
  public void renderLiving(RenderLivingEvent.Post event) {

    if (BattlegearConfig.enableSkeletonQuiver
        && event.entity instanceof EntitySkeleton
        && event.renderer instanceof RenderSkeleton) {

      GL11.glPushMatrix();
      GL11.glDisable(GL11.GL_CULL_FACE);

      GL11.glColor3f(1, 1, 1);
      Minecraft.getMinecraft().getTextureManager().bindTexture(quiverDetails);

      GL11.glTranslatef((float) event.x, (float) event.y, (float) event.z);

      GL11.glScalef(1, -1, 1);

      float f2 =
          interpolateRotation(event.entity.prevRenderYawOffset, event.entity.renderYawOffset, 0);

      GL11.glRotatef(180.0F - f2, 0.0F, 1.0F, 0.0F);

      if (event.entity.deathTime > 0) {
        float f3 =
            ((float) event.entity.deathTime + BattlegearClientTickHandeler.getPartialTick() - 1.0F)
                / 20.0F
                * 1.6F;
        f3 = MathHelper.sqrt_float(f3);

        if (f3 > 1.0F) {
          f3 = 1.0F;
        }

        GL11.glRotatef(-f3 * 90, 0.0F, 0.0F, 1.0F);
      }

      GL11.glTranslatef(0, -1.5F, 0);

      GL11.glRotatef(event.entity.rotationPitch, 0, 1, 0);

      if (event.entity.getEquipmentInSlot(3) != null) { // chest armor
        GL11.glTranslatef(0, 0, BattlegearRenderHelper.RENDER_UNIT);
      }
      ((ModelBiped) event.renderer.mainModel)
          .bipedBody.postRender(BattlegearRenderHelper.RENDER_UNIT);
      GL11.glScalef(1.05F, 1.05F, 1.05F);
      quiverModel.render(SKELETON_ARROW, BattlegearRenderHelper.RENDER_UNIT);

      Minecraft.getMinecraft().getTextureManager().bindTexture(quiverBase);
      GL11.glColor3f(0.10F, 0.10F, 0.10F);
      quiverModel.render(0, BattlegearRenderHelper.RENDER_UNIT);
      GL11.glColor3f(1, 1, 1);

      GL11.glEnable(GL11.GL_CULL_FACE);
      GL11.glPopMatrix();
    }
  }

  /** Counter the bow use fov jerkyness with the draw enchantment */
  @SubscribeEvent
  public void onBowFOV(FOVUpdateEvent event) {
    ItemStack stack = event.entity.getItemInUse();
    if (EnchantmentHelper.getEnchantmentLevel(BaseEnchantment.bowCharge, stack) > 0) {
      int i = event.entity.getItemInUseDuration();
      float f1 = (float) i / 20.0F;
      if (f1 > 1.0F) {
        f1 = 1.0F;
      } else {
        f1 *= f1;
      }
      event.newfov /= 1.0F - f1 * 0.15F;
    }
  }

  /** Fixes pick block */
  @SubscribeEvent(priority = EventPriority.HIGHEST)
  public void replacePickBlock(MouseEvent event) {
    if (event.buttonstate) {
      Minecraft mc = FMLClientHandler.instance().getClient();
      if (mc.thePlayer != null) {
        if (event.button - 100 == mc.gameSettings.keyBindPickBlock.getKeyCode()) {
          event.setCanceled(true);
          if (!((IBattlePlayer) mc.thePlayer).isBattlemode()) {
            boolean isCreative = mc.thePlayer.capabilities.isCreativeMode;
            ItemStack stack = getItemFromPointedAt(mc.objectMouseOver, mc.thePlayer);
            if (stack != null) {
              int k = -1;
              ItemStack temp;
              for (int slot = 0; slot < MAIN_INV; slot++) {
                temp = mc.thePlayer.inventory.getStackInSlot(slot);
                if (temp != null
                    && stack.isItemEqual(temp)
                    && ItemStack.areItemStackTagsEqual(stack, temp)) {
                  k = slot;
                  break;
                }
              }
              if (isCreative && k == -1) {
                k = mc.thePlayer.inventory.getFirstEmptyStack();
                if (k < 0 || k >= MAIN_INV) {
                  k = mc.thePlayer.inventory.currentItem;
                }
              }
              if (k >= 0 && k < MAIN_INV) {
                mc.thePlayer.inventory.currentItem = k;
                Battlegear.packetHandler.sendPacketToServer(
                    new PickBlockPacket(stack, k).generatePacket());
              }
            }
          }
        }
      }
    }
  }

  /**
   * Equivalent code to the creative pick block
   *
   * @param target The client target vector
   * @param player The player trying to pick
   * @return the stack expected for the creative pick button
   */
  private static ItemStack getItemFromPointedAt(MovingObjectPosition target, EntityPlayer player) {
    if (target != null) {
      if (target.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
        BlockPos pos = target.getBlockPos();
        World world = player.getEntityWorld();
        Block block = world.getBlockState(pos).getBlock();
        if (block.isAir(world, pos)) {
          return null;
        }
        return block.getPickBlock(target, world, pos);
      } else {
        if (target.typeOfHit != MovingObjectPosition.MovingObjectType.ENTITY
            || target.entityHit == null
            || !player.capabilities.isCreativeMode) {
          return null;
        }
        return target.entityHit.getPickedResult(target);
      }
    }
    return null;
  }

  /**
   * Returns a rotation angle that is inbetween two other rotation angles. par1 and par2 are the
   * angles between which to interpolate, par3 is probably a float between 0.0 and 1.0 that tells us
   * where "between" the two angles we are. Example: par1 = 30, par2 = 50, par3 = 0.5, then return =
   * 40
   */
  public float interpolateRotation(float par1, float par2, float par3) {
    float f3 = par2 - par1;

    while (f3 < -180.0F) {
      f3 += 360.0F;
    }

    while (f3 >= 180.0F) {
      f3 -= 360.0F;
    }

    return par1 + par3 * f3;
  }

  /** Register a few "item" icons */
  @SubscribeEvent
  public void preStitch(TextureStitchEvent.Pre event) {
    ClientProxy.backgroundIcon =
        new TextureAtlasSprite[] {
          event.map.registerSprite(new ResourceLocation("battlegear2:items/slots/mainhand")),
          event.map.registerSprite(new ResourceLocation("battlegear2:items/slots/offhand"))
        };

    // storageIndex = PatternStore.DEFAULT.buildPatternAndStore(patterns);
    /*CrestImages.initialise(Minecraft.getMinecraft().getResourceManager());
    for (HeraldryPattern pattern : HeraldryPattern.patterns) {
        pattern.registerIcon(event.map);
    }*/
  }

  /**
   * Change attribute format when displayed on item tooltip
   *
   * @param event
   */
  @SubscribeEvent
  public void onItemTooltip(ItemTooltipEvent event) {
    for (String txt : event.toolTip) {
      if (txt.startsWith(EnumChatFormatting.BLUE.toString())) {
        if (txt.contains(attributeNames[0]) || txt.contains(attributeNames[2]))
          event.toolTip.set(
              event.toolTip.indexOf(txt),
              EnumChatFormatting.DARK_GREEN
                  + EnumChatFormatting.getTextWithoutFormattingCodes(txt));
        else if (txt.contains(attributeNames[3]))
          event.toolTip.set(
              event.toolTip.indexOf(txt), EnumChatFormatting.DARK_GREEN + reformat(txt, 3));
        else if (txt.contains(attributeNames[1]))
          event.toolTip.set(event.toolTip.indexOf(txt), EnumChatFormatting.GOLD + reformat(txt, 1));
      }
    }
    if (event.itemStack.getItem() instanceof IBackStabbable) {
      event.toolTip.add(
          EnumChatFormatting.GOLD
              + StatCollector.translateToLocal("attribute.name.weapon.backstab"));
    }
  }

  // Equivalent of the ItemStack decimal formatter used in attribute tooltip display
  private static final Pattern FLOAT = Pattern.compile("\\d.\\d+");

  /**
   * Format into "ratio" attribute localization
   *
   * @param txt current attribute local
   * @param type the attribute index
   * @return the new localization
   */
  private String reformat(String txt, int type) {
    String result = EnumChatFormatting.getTextWithoutFormattingCodes(txt);
    Matcher matcher = FLOAT.matcher(result);
    if (matcher.find()) {
      int start = matcher.start();
      int end = matcher.end();
      String temp = result.substring(start, end).replace(",", ".");
      try {
        float value = Float.valueOf(temp) * 100;
        temp = ".plus.1";
        if (start > 0 && result.charAt(start - 1) == '-') {
          temp = ".take.1";
        }
        return StatCollector.translateToLocalFormatted(
            "attribute.modifier" + temp,
            ItemStack.DECIMALFORMAT.format(value),
            attributeNames[type]);
      } catch (NumberFormatException notNumber) {
        notNumber.printStackTrace();
      }
    }

    return result;
  }

  /**
   * Help translating attributes
   *
   * @param attribute
   * @return the attribute name into the current language
   */
  private String toLocal(BaseAttribute attribute) {
    return StatCollector.translateToLocal(
        "attribute.name." + attribute.getAttributeUnlocalizedName());
  }

  /** Reload translation caches */
  @Override
  public void onResourceManagerReload(IResourceManager resourceManager) {
    attributeNames =
        new String[] {
          toLocal(Attributes.armourPenetrate),
          toLocal(Attributes.daze),
          toLocal(Attributes.extendedReach),
          toLocal(Attributes.attackSpeed)
        };
  }

  @SubscribeEvent(priority = EventPriority.LOW)
  public void postInitGui(GuiScreenEvent.InitGuiEvent.Post event) {
    if (Battlegear.battlegearEnabled && event.gui instanceof InventoryEffectRenderer) {
      if (!ClientProxy.tconstructEnabled
          || FMLClientHandler.instance().getClientPlayerEntity().capabilities.isCreativeMode) {
        onOpenGui(
            event.buttonList,
            ((InventoryEffectRenderer) event.gui).guiLeft - 30,
            ((InventoryEffectRenderer) event.gui).guiTop);
      }
    }
  }

  /**
   * Helper method to add buttons to a gui when opened
   *
   * @param buttons the List<GuiButton> of the opened gui
   * @param guiLeft horizontal placement parameter
   * @param guiTop vertical placement parameter
   */
  public static void onOpenGui(List buttons, int guiLeft, int guiTop) {
    if (BattlegearConfig.enableGuiButtons) {
      int count = 0;
      for (GuiPlaceableButton tab : tabsList) {
        GuiPlaceableButton button = tab.copy();
        button.place(count, guiLeft, guiTop);
        button.id =
            buttons.size()
                + 2; // Due to GuiInventory and GuiContainerCreative button performed actions,
        // without them having buttons...
        count++;
        buttons.add(button);
      }
    }
  }
}
 @Override
 public ItemStack getHelmet() {
   return new BukkitItemStack(realInv.armorItemInSlot(3));
 }
 @Override
 public int clear(int id, int data) {
   return realInv.clearInventory(id, data);
 }
 @Override
 public ItemStack getChestplate() {
   return new BukkitItemStack(realInv.armorItemInSlot(2));
 }
 @Override
 public ItemStack getLeggings() {
   return new BukkitItemStack(realInv.armorItemInSlot(1));
 }
 @Override
 public ItemStack getBoots() {
   return new BukkitItemStack(realInv.armorItemInSlot(0));
 }
 @Override
 public ItemStack getItemInHand() {
   return new BukkitItemStack(realInv.getCurrentItem());
 }
  public ContainerCosArmor(
      InventoryPlayer invPlayer, InventoryCosArmor invCosArmor, EntityPlayer player) {
    this.player = player;

    // CraftingResult
    addSlotToContainer(new SlotCrafting(player, craftMatrix, craftResult, 0, 154, 28));

    // CraftingGrid
    for (int i = 0; i < 2; i++)
      for (int j = 0; j < 2; j++)
        addSlotToContainer(new Slot(craftMatrix, j + i * 2, 98 + j * 18, 18 + i * 18));

    // NormalArmor
    for (int i = 0; i < 4; i++) {
      final int j = i;
      final EntityPlayer k = player;
      addSlotToContainer(
          new Slot(
              invPlayer,
              invPlayer.getSizeInventory() - 1 - invPlayer.offHandInventory.size() - i,
              8,
              8 + i * 18) {

            @Override
            public int getSlotStackLimit() {
              return 1;
            }

            @SideOnly(Side.CLIENT)
            @Override
            public String getSlotTexture() {
              return ItemArmor.EMPTY_SLOT_NAMES[VALID_EQUIPMENT_SLOTS[j].getIndex()];
            }

            @Override
            public boolean isItemValid(ItemStack stack) {
              if (stack == null || stack.func_190926_b()) return false;

              return stack.getItem().isValidArmor(stack, VALID_EQUIPMENT_SLOTS[j], k);
            }
          });
    }

    // CosmeticArmor
    for (int i = 0; i < 4; i++) {
      final int j = i;
      final EntityPlayer k = player;
      addSlotToContainer(
          new Slot(invCosArmor, invCosArmor.getSizeInventory() - 1 - i, 98 + i * 18, 62) {

            @Override
            public int getSlotStackLimit() {
              return 1;
            }

            @SideOnly(Side.CLIENT)
            @Override
            public String getSlotTexture() {
              return ItemArmor.EMPTY_SLOT_NAMES[VALID_EQUIPMENT_SLOTS[j].getIndex()];
            }

            @Override
            public boolean isItemValid(ItemStack stack) {
              if (stack == null || stack.func_190926_b()) return false;

              return stack.getItem().isValidArmor(stack, VALID_EQUIPMENT_SLOTS[j], k);
            }
          });
    }

    // PlayerInventory
    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 9; j++)
        addSlotToContainer(new Slot(invPlayer, j + (i + 1) * 9, 8 + j * 18, 84 + i * 18));

    // PlayerHotBar
    for (int i = 0; i < 9; i++) addSlotToContainer(new Slot(invPlayer, i, 8 + i * 18, 142));

    // Off-Hand Slot
    addSlotToContainer(
        new Slot(invPlayer, 40, 77, 62) {

          @SideOnly(Side.CLIENT)
          @Override
          public String getSlotTexture() {
            return "minecraft:items/empty_armor_slot_shield";
          }
        });

    onCraftMatrixChanged(craftMatrix);
  }