001package net.minecraft.inventory; 002 003import cpw.mods.fml.relauncher.Side; 004import cpw.mods.fml.relauncher.SideOnly; 005import java.util.ArrayList; 006import java.util.HashSet; 007import java.util.Iterator; 008import java.util.List; 009import java.util.Set; 010import net.minecraft.entity.player.EntityPlayer; 011import net.minecraft.entity.player.InventoryPlayer; 012import net.minecraft.item.ItemStack; 013import net.minecraft.util.MathHelper; 014 015public abstract class Container 016{ 017 /** the list of all items(stacks) for the corresponding slot */ 018 public List inventoryItemStacks = new ArrayList(); 019 020 /** the list of all slots in the inventory */ 021 public List inventorySlots = new ArrayList(); 022 public int windowId = 0; 023 private short transactionID = 0; 024 private int field_94535_f = -1; 025 private int field_94536_g = 0; 026 private final Set field_94537_h = new HashSet(); 027 028 /** 029 * list of all people that need to be notified when this craftinventory changes 030 */ 031 protected List crafters = new ArrayList(); 032 private Set playerList = new HashSet(); 033 034 /** 035 * the slot is assumed empty 036 */ 037 protected Slot addSlotToContainer(Slot par1Slot) 038 { 039 par1Slot.slotNumber = this.inventorySlots.size(); 040 this.inventorySlots.add(par1Slot); 041 this.inventoryItemStacks.add((Object)null); 042 return par1Slot; 043 } 044 045 public void addCraftingToCrafters(ICrafting par1ICrafting) 046 { 047 if (this.crafters.contains(par1ICrafting)) 048 { 049 throw new IllegalArgumentException("Listener already listening"); 050 } 051 else 052 { 053 this.crafters.add(par1ICrafting); 054 par1ICrafting.sendContainerAndContentsToPlayer(this, this.getInventory()); 055 this.detectAndSendChanges(); 056 } 057 } 058 059 /** 060 * returns a list if itemStacks, for each slot. 061 */ 062 public List getInventory() 063 { 064 ArrayList arraylist = new ArrayList(); 065 066 for (int i = 0; i < this.inventorySlots.size(); ++i) 067 { 068 arraylist.add(((Slot)this.inventorySlots.get(i)).getStack()); 069 } 070 071 return arraylist; 072 } 073 074 @SideOnly(Side.CLIENT) 075 076 /** 077 * Remove this crafting listener from the listener list. 078 */ 079 public void removeCraftingFromCrafters(ICrafting par1ICrafting) 080 { 081 this.crafters.remove(par1ICrafting); 082 } 083 084 /** 085 * Looks for changes made in the container, sends them to every listener. 086 */ 087 public void detectAndSendChanges() 088 { 089 for (int i = 0; i < this.inventorySlots.size(); ++i) 090 { 091 ItemStack itemstack = ((Slot)this.inventorySlots.get(i)).getStack(); 092 ItemStack itemstack1 = (ItemStack)this.inventoryItemStacks.get(i); 093 094 if (!ItemStack.areItemStacksEqual(itemstack1, itemstack)) 095 { 096 itemstack1 = itemstack == null ? null : itemstack.copy(); 097 this.inventoryItemStacks.set(i, itemstack1); 098 099 for (int j = 0; j < this.crafters.size(); ++j) 100 { 101 ((ICrafting)this.crafters.get(j)).sendSlotContents(this, i, itemstack1); 102 } 103 } 104 } 105 } 106 107 /** 108 * enchants the item on the table using the specified slot; also deducts XP from player 109 */ 110 public boolean enchantItem(EntityPlayer par1EntityPlayer, int par2) 111 { 112 return false; 113 } 114 115 public Slot getSlotFromInventory(IInventory par1IInventory, int par2) 116 { 117 for (int j = 0; j < this.inventorySlots.size(); ++j) 118 { 119 Slot slot = (Slot)this.inventorySlots.get(j); 120 121 if (slot.isSlotInInventory(par1IInventory, par2)) 122 { 123 return slot; 124 } 125 } 126 127 return null; 128 } 129 130 public Slot getSlot(int par1) 131 { 132 return (Slot)this.inventorySlots.get(par1); 133 } 134 135 /** 136 * Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that. 137 */ 138 public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2) 139 { 140 Slot slot = (Slot)this.inventorySlots.get(par2); 141 return slot != null ? slot.getStack() : null; 142 } 143 144 public ItemStack slotClick(int par1, int par2, int par3, EntityPlayer par4EntityPlayer) 145 { 146 ItemStack itemstack = null; 147 InventoryPlayer inventoryplayer = par4EntityPlayer.inventory; 148 int l; 149 ItemStack itemstack1; 150 151 if (par3 == 5) 152 { 153 int i1 = this.field_94536_g; 154 this.field_94536_g = func_94532_c(par2); 155 156 if ((i1 != 1 || this.field_94536_g != 2) && i1 != this.field_94536_g) 157 { 158 this.func_94533_d(); 159 } 160 else if (inventoryplayer.getItemStack() == null) 161 { 162 this.func_94533_d(); 163 } 164 else if (this.field_94536_g == 0) 165 { 166 this.field_94535_f = func_94529_b(par2); 167 168 if (func_94528_d(this.field_94535_f)) 169 { 170 this.field_94536_g = 1; 171 this.field_94537_h.clear(); 172 } 173 else 174 { 175 this.func_94533_d(); 176 } 177 } 178 else if (this.field_94536_g == 1) 179 { 180 Slot slot = (Slot)this.inventorySlots.get(par1); 181 182 if (slot != null && func_94527_a(slot, inventoryplayer.getItemStack(), true) && slot.isItemValid(inventoryplayer.getItemStack()) && inventoryplayer.getItemStack().stackSize > this.field_94537_h.size() && this.func_94531_b(slot)) 183 { 184 this.field_94537_h.add(slot); 185 } 186 } 187 else if (this.field_94536_g == 2) 188 { 189 if (!this.field_94537_h.isEmpty()) 190 { 191 itemstack1 = inventoryplayer.getItemStack().copy(); 192 l = inventoryplayer.getItemStack().stackSize; 193 Iterator iterator = this.field_94537_h.iterator(); 194 195 while (iterator.hasNext()) 196 { 197 Slot slot1 = (Slot)iterator.next(); 198 199 if (slot1 != null && func_94527_a(slot1, inventoryplayer.getItemStack(), true) && slot1.isItemValid(inventoryplayer.getItemStack()) && inventoryplayer.getItemStack().stackSize >= this.field_94537_h.size() && this.func_94531_b(slot1)) 200 { 201 ItemStack itemstack2 = itemstack1.copy(); 202 int j1 = slot1.getHasStack() ? slot1.getStack().stackSize : 0; 203 func_94525_a(this.field_94537_h, this.field_94535_f, itemstack2, j1); 204 205 if (itemstack2.stackSize > itemstack2.getMaxStackSize()) 206 { 207 itemstack2.stackSize = itemstack2.getMaxStackSize(); 208 } 209 210 if (itemstack2.stackSize > slot1.getSlotStackLimit()) 211 { 212 itemstack2.stackSize = slot1.getSlotStackLimit(); 213 } 214 215 l -= itemstack2.stackSize - j1; 216 slot1.putStack(itemstack2); 217 } 218 } 219 220 itemstack1.stackSize = l; 221 222 if (itemstack1.stackSize <= 0) 223 { 224 itemstack1 = null; 225 } 226 227 inventoryplayer.setItemStack(itemstack1); 228 } 229 230 this.func_94533_d(); 231 } 232 else 233 { 234 this.func_94533_d(); 235 } 236 } 237 else if (this.field_94536_g != 0) 238 { 239 this.func_94533_d(); 240 } 241 else 242 { 243 Slot slot2; 244 int k1; 245 ItemStack itemstack3; 246 247 if ((par3 == 0 || par3 == 1) && (par2 == 0 || par2 == 1)) 248 { 249 if (par1 == -999) 250 { 251 if (inventoryplayer.getItemStack() != null && par1 == -999) 252 { 253 if (par2 == 0) 254 { 255 par4EntityPlayer.dropPlayerItem(inventoryplayer.getItemStack()); 256 inventoryplayer.setItemStack((ItemStack)null); 257 } 258 259 if (par2 == 1) 260 { 261 par4EntityPlayer.dropPlayerItem(inventoryplayer.getItemStack().splitStack(1)); 262 263 if (inventoryplayer.getItemStack().stackSize == 0) 264 { 265 inventoryplayer.setItemStack((ItemStack)null); 266 } 267 } 268 } 269 } 270 else if (par3 == 1) 271 { 272 if (par1 < 0) 273 { 274 return null; 275 } 276 277 slot2 = (Slot)this.inventorySlots.get(par1); 278 279 if (slot2 != null && slot2.canTakeStack(par4EntityPlayer)) 280 { 281 itemstack1 = this.transferStackInSlot(par4EntityPlayer, par1); 282 283 if (itemstack1 != null) 284 { 285 l = itemstack1.itemID; 286 itemstack = itemstack1.copy(); 287 288 if (slot2 != null && slot2.getStack() != null && slot2.getStack().itemID == l) 289 { 290 this.retrySlotClick(par1, par2, true, par4EntityPlayer); 291 } 292 } 293 } 294 } 295 else 296 { 297 if (par1 < 0) 298 { 299 return null; 300 } 301 302 slot2 = (Slot)this.inventorySlots.get(par1); 303 304 if (slot2 != null) 305 { 306 itemstack1 = slot2.getStack(); 307 ItemStack itemstack4 = inventoryplayer.getItemStack(); 308 309 if (itemstack1 != null) 310 { 311 itemstack = itemstack1.copy(); 312 } 313 314 if (itemstack1 == null) 315 { 316 if (itemstack4 != null && slot2.isItemValid(itemstack4)) 317 { 318 k1 = par2 == 0 ? itemstack4.stackSize : 1; 319 320 if (k1 > slot2.getSlotStackLimit()) 321 { 322 k1 = slot2.getSlotStackLimit(); 323 } 324 325 slot2.putStack(itemstack4.splitStack(k1)); 326 327 if (itemstack4.stackSize == 0) 328 { 329 inventoryplayer.setItemStack((ItemStack)null); 330 } 331 } 332 } 333 else if (slot2.canTakeStack(par4EntityPlayer)) 334 { 335 if (itemstack4 == null) 336 { 337 k1 = par2 == 0 ? itemstack1.stackSize : (itemstack1.stackSize + 1) / 2; 338 itemstack3 = slot2.decrStackSize(k1); 339 inventoryplayer.setItemStack(itemstack3); 340 341 if (itemstack1.stackSize == 0) 342 { 343 slot2.putStack((ItemStack)null); 344 } 345 346 slot2.onPickupFromSlot(par4EntityPlayer, inventoryplayer.getItemStack()); 347 } 348 else if (slot2.isItemValid(itemstack4)) 349 { 350 if (itemstack1.itemID == itemstack4.itemID && itemstack1.getItemDamage() == itemstack4.getItemDamage() && ItemStack.areItemStackTagsEqual(itemstack1, itemstack4)) 351 { 352 k1 = par2 == 0 ? itemstack4.stackSize : 1; 353 354 if (k1 > slot2.getSlotStackLimit() - itemstack1.stackSize) 355 { 356 k1 = slot2.getSlotStackLimit() - itemstack1.stackSize; 357 } 358 359 if (k1 > itemstack4.getMaxStackSize() - itemstack1.stackSize) 360 { 361 k1 = itemstack4.getMaxStackSize() - itemstack1.stackSize; 362 } 363 364 itemstack4.splitStack(k1); 365 366 if (itemstack4.stackSize == 0) 367 { 368 inventoryplayer.setItemStack((ItemStack)null); 369 } 370 371 itemstack1.stackSize += k1; 372 } 373 else if (itemstack4.stackSize <= slot2.getSlotStackLimit()) 374 { 375 slot2.putStack(itemstack4); 376 inventoryplayer.setItemStack(itemstack1); 377 } 378 } 379 else if (itemstack1.itemID == itemstack4.itemID && itemstack4.getMaxStackSize() > 1 && (!itemstack1.getHasSubtypes() || itemstack1.getItemDamage() == itemstack4.getItemDamage()) && ItemStack.areItemStackTagsEqual(itemstack1, itemstack4)) 380 { 381 k1 = itemstack1.stackSize; 382 383 if (k1 > 0 && k1 + itemstack4.stackSize <= itemstack4.getMaxStackSize()) 384 { 385 itemstack4.stackSize += k1; 386 itemstack1 = slot2.decrStackSize(k1); 387 388 if (itemstack1.stackSize == 0) 389 { 390 slot2.putStack((ItemStack)null); 391 } 392 393 slot2.onPickupFromSlot(par4EntityPlayer, inventoryplayer.getItemStack()); 394 } 395 } 396 } 397 398 slot2.onSlotChanged(); 399 } 400 } 401 } 402 else if (par3 == 2 && par2 >= 0 && par2 < 9) 403 { 404 slot2 = (Slot)this.inventorySlots.get(par1); 405 406 if (slot2.canTakeStack(par4EntityPlayer)) 407 { 408 itemstack1 = inventoryplayer.getStackInSlot(par2); 409 boolean flag = itemstack1 == null || slot2.inventory == inventoryplayer && slot2.isItemValid(itemstack1); 410 k1 = -1; 411 412 if (!flag) 413 { 414 k1 = inventoryplayer.getFirstEmptyStack(); 415 flag |= k1 > -1; 416 } 417 418 if (slot2.getHasStack() && flag) 419 { 420 itemstack3 = slot2.getStack(); 421 inventoryplayer.setInventorySlotContents(par2, itemstack3); 422 423 if ((slot2.inventory != inventoryplayer || !slot2.isItemValid(itemstack1)) && itemstack1 != null) 424 { 425 if (k1 > -1) 426 { 427 inventoryplayer.addItemStackToInventory(itemstack1); 428 slot2.decrStackSize(itemstack3.stackSize); 429 slot2.putStack((ItemStack)null); 430 slot2.onPickupFromSlot(par4EntityPlayer, itemstack3); 431 } 432 } 433 else 434 { 435 slot2.decrStackSize(itemstack3.stackSize); 436 slot2.putStack(itemstack1); 437 slot2.onPickupFromSlot(par4EntityPlayer, itemstack3); 438 } 439 } 440 else if (!slot2.getHasStack() && itemstack1 != null && slot2.isItemValid(itemstack1)) 441 { 442 inventoryplayer.setInventorySlotContents(par2, (ItemStack)null); 443 slot2.putStack(itemstack1); 444 } 445 } 446 } 447 else if (par3 == 3 && par4EntityPlayer.capabilities.isCreativeMode && inventoryplayer.getItemStack() == null && par1 >= 0) 448 { 449 slot2 = (Slot)this.inventorySlots.get(par1); 450 451 if (slot2 != null && slot2.getHasStack()) 452 { 453 itemstack1 = slot2.getStack().copy(); 454 itemstack1.stackSize = itemstack1.getMaxStackSize(); 455 inventoryplayer.setItemStack(itemstack1); 456 } 457 } 458 else if (par3 == 4 && inventoryplayer.getItemStack() == null && par1 >= 0) 459 { 460 slot2 = (Slot)this.inventorySlots.get(par1); 461 462 if (slot2 != null && slot2.getHasStack()) 463 { 464 itemstack1 = slot2.decrStackSize(par2 == 0 ? 1 : slot2.getStack().stackSize); 465 slot2.onPickupFromSlot(par4EntityPlayer, itemstack1); 466 par4EntityPlayer.dropPlayerItem(itemstack1); 467 } 468 } 469 else if (par3 == 6 && par1 >= 0) 470 { 471 slot2 = (Slot)this.inventorySlots.get(par1); 472 itemstack1 = inventoryplayer.getItemStack(); 473 474 if (itemstack1 != null && (slot2 == null || !slot2.getHasStack() || !slot2.canTakeStack(par4EntityPlayer))) 475 { 476 l = par2 == 0 ? 0 : this.inventorySlots.size() - 1; 477 k1 = par2 == 0 ? 1 : -1; 478 479 for (int l1 = 0; l1 < 2; ++l1) 480 { 481 for (int i2 = l; i2 >= 0 && i2 < this.inventorySlots.size() && itemstack1.stackSize < itemstack1.getMaxStackSize(); i2 += k1) 482 { 483 Slot slot3 = (Slot)this.inventorySlots.get(i2); 484 485 if (slot3.getHasStack() && func_94527_a(slot3, itemstack1, true) && slot3.canTakeStack(par4EntityPlayer) && this.func_94530_a(itemstack1, slot3) && (l1 != 0 || slot3.getStack().stackSize != slot3.getStack().getMaxStackSize())) 486 { 487 int j2 = Math.min(itemstack1.getMaxStackSize() - itemstack1.stackSize, slot3.getStack().stackSize); 488 ItemStack itemstack5 = slot3.decrStackSize(j2); 489 itemstack1.stackSize += j2; 490 491 if (itemstack5.stackSize <= 0) 492 { 493 slot3.putStack((ItemStack)null); 494 } 495 496 slot3.onPickupFromSlot(par4EntityPlayer, itemstack5); 497 } 498 } 499 } 500 } 501 502 this.detectAndSendChanges(); 503 } 504 } 505 506 return itemstack; 507 } 508 509 public boolean func_94530_a(ItemStack par1ItemStack, Slot par2Slot) 510 { 511 return true; 512 } 513 514 protected void retrySlotClick(int par1, int par2, boolean par3, EntityPlayer par4EntityPlayer) 515 { 516 this.slotClick(par1, par2, 1, par4EntityPlayer); 517 } 518 519 /** 520 * Callback for when the crafting gui is closed. 521 */ 522 public void onCraftGuiClosed(EntityPlayer par1EntityPlayer) 523 { 524 InventoryPlayer inventoryplayer = par1EntityPlayer.inventory; 525 526 if (inventoryplayer.getItemStack() != null) 527 { 528 par1EntityPlayer.dropPlayerItem(inventoryplayer.getItemStack()); 529 inventoryplayer.setItemStack((ItemStack)null); 530 } 531 } 532 533 /** 534 * Callback for when the crafting matrix is changed. 535 */ 536 public void onCraftMatrixChanged(IInventory par1IInventory) 537 { 538 this.detectAndSendChanges(); 539 } 540 541 /** 542 * args: slotID, itemStack to put in slot 543 */ 544 public void putStackInSlot(int par1, ItemStack par2ItemStack) 545 { 546 this.getSlot(par1).putStack(par2ItemStack); 547 } 548 549 @SideOnly(Side.CLIENT) 550 551 /** 552 * places itemstacks in first x slots, x being aitemstack.lenght 553 */ 554 public void putStacksInSlots(ItemStack[] par1ArrayOfItemStack) 555 { 556 for (int i = 0; i < par1ArrayOfItemStack.length; ++i) 557 { 558 this.getSlot(i).putStack(par1ArrayOfItemStack[i]); 559 } 560 } 561 562 @SideOnly(Side.CLIENT) 563 public void updateProgressBar(int par1, int par2) {} 564 565 @SideOnly(Side.CLIENT) 566 567 /** 568 * Gets a unique transaction ID. Parameter is unused. 569 */ 570 public short getNextTransactionID(InventoryPlayer par1InventoryPlayer) 571 { 572 ++this.transactionID; 573 return this.transactionID; 574 } 575 576 /** 577 * NotUsing because adding a player twice is an error 578 */ 579 public boolean isPlayerNotUsingContainer(EntityPlayer par1EntityPlayer) 580 { 581 return !this.playerList.contains(par1EntityPlayer); 582 } 583 584 /** 585 * adds or removes the player from the container based on par2 586 */ 587 public void setPlayerIsPresent(EntityPlayer par1EntityPlayer, boolean par2) 588 { 589 if (par2) 590 { 591 this.playerList.remove(par1EntityPlayer); 592 } 593 else 594 { 595 this.playerList.add(par1EntityPlayer); 596 } 597 } 598 599 public abstract boolean canInteractWith(EntityPlayer entityplayer); 600 601 /** 602 * merges provided ItemStack with the first avaliable one in the container/player inventory 603 */ 604 protected boolean mergeItemStack(ItemStack par1ItemStack, int par2, int par3, boolean par4) 605 { 606 boolean flag1 = false; 607 int k = par2; 608 609 if (par4) 610 { 611 k = par3 - 1; 612 } 613 614 Slot slot; 615 ItemStack itemstack1; 616 617 if (par1ItemStack.isStackable()) 618 { 619 while (par1ItemStack.stackSize > 0 && (!par4 && k < par3 || par4 && k >= par2)) 620 { 621 slot = (Slot)this.inventorySlots.get(k); 622 itemstack1 = slot.getStack(); 623 624 if (itemstack1 != null && itemstack1.itemID == par1ItemStack.itemID && (!par1ItemStack.getHasSubtypes() || par1ItemStack.getItemDamage() == itemstack1.getItemDamage()) && ItemStack.areItemStackTagsEqual(par1ItemStack, itemstack1)) 625 { 626 int l = itemstack1.stackSize + par1ItemStack.stackSize; 627 628 if (l <= par1ItemStack.getMaxStackSize()) 629 { 630 par1ItemStack.stackSize = 0; 631 itemstack1.stackSize = l; 632 slot.onSlotChanged(); 633 flag1 = true; 634 } 635 else if (itemstack1.stackSize < par1ItemStack.getMaxStackSize()) 636 { 637 par1ItemStack.stackSize -= par1ItemStack.getMaxStackSize() - itemstack1.stackSize; 638 itemstack1.stackSize = par1ItemStack.getMaxStackSize(); 639 slot.onSlotChanged(); 640 flag1 = true; 641 } 642 } 643 644 if (par4) 645 { 646 --k; 647 } 648 else 649 { 650 ++k; 651 } 652 } 653 } 654 655 if (par1ItemStack.stackSize > 0) 656 { 657 if (par4) 658 { 659 k = par3 - 1; 660 } 661 else 662 { 663 k = par2; 664 } 665 666 while (!par4 && k < par3 || par4 && k >= par2) 667 { 668 slot = (Slot)this.inventorySlots.get(k); 669 itemstack1 = slot.getStack(); 670 671 if (itemstack1 == null) 672 { 673 slot.putStack(par1ItemStack.copy()); 674 slot.onSlotChanged(); 675 par1ItemStack.stackSize = 0; 676 flag1 = true; 677 break; 678 } 679 680 if (par4) 681 { 682 --k; 683 } 684 else 685 { 686 ++k; 687 } 688 } 689 } 690 691 return flag1; 692 } 693 694 public static int func_94529_b(int par0) 695 { 696 return par0 >> 2 & 3; 697 } 698 699 public static int func_94532_c(int par0) 700 { 701 return par0 & 3; 702 } 703 704 @SideOnly(Side.CLIENT) 705 public static int func_94534_d(int par0, int par1) 706 { 707 return par0 & 3 | (par1 & 3) << 2; 708 } 709 710 public static boolean func_94528_d(int par0) 711 { 712 return par0 == 0 || par0 == 1; 713 } 714 715 protected void func_94533_d() 716 { 717 this.field_94536_g = 0; 718 this.field_94537_h.clear(); 719 } 720 721 public static boolean func_94527_a(Slot par0Slot, ItemStack par1ItemStack, boolean par2) 722 { 723 boolean flag1 = par0Slot == null || !par0Slot.getHasStack(); 724 725 if (par0Slot != null && par0Slot.getHasStack() && par1ItemStack != null && par1ItemStack.isItemEqual(par0Slot.getStack()) && ItemStack.areItemStackTagsEqual(par0Slot.getStack(), par1ItemStack)) 726 { 727 int i = par2 ? 0 : par1ItemStack.stackSize; 728 flag1 |= par0Slot.getStack().stackSize + i <= par1ItemStack.getMaxStackSize(); 729 } 730 731 return flag1; 732 } 733 734 public static void func_94525_a(Set par0Set, int par1, ItemStack par2ItemStack, int par3) 735 { 736 switch (par1) 737 { 738 case 0: 739 par2ItemStack.stackSize = MathHelper.floor_float((float)par2ItemStack.stackSize / (float)par0Set.size()); 740 break; 741 case 1: 742 par2ItemStack.stackSize = 1; 743 } 744 745 par2ItemStack.stackSize += par3; 746 } 747 748 public boolean func_94531_b(Slot par1Slot) 749 { 750 return true; 751 } 752 753 public static int func_94526_b(IInventory par0IInventory) 754 { 755 if (par0IInventory == null) 756 { 757 return 0; 758 } 759 else 760 { 761 int i = 0; 762 float f = 0.0F; 763 764 for (int j = 0; j < par0IInventory.getSizeInventory(); ++j) 765 { 766 ItemStack itemstack = par0IInventory.getStackInSlot(j); 767 768 if (itemstack != null) 769 { 770 f += (float)itemstack.stackSize / (float)Math.min(par0IInventory.getInventoryStackLimit(), itemstack.getMaxStackSize()); 771 ++i; 772 } 773 } 774 775 f /= (float)par0IInventory.getSizeInventory(); 776 return MathHelper.floor_float(f * 14.0F) + (i > 0 ? 1 : 0); 777 } 778 } 779}