@Override
 protected void onInventoryClick(InventoryClickEvent event, Player player) {
   event.setCancelled(true);
   final int slot = event.getRawSlot();
   if (slot >= 0 && slot <= 7) {
     // handle changing sell stack size
     ItemStack item = event.getCurrentItem();
     if (item != null && item.getType() != Material.AIR) {
       int amount = item.getAmount();
       amount = this.getNewAmountAfterEditorClick(event, amount);
       if (amount <= 0) amount = 1;
       if (amount > item.getMaxStackSize()) amount = item.getMaxStackSize();
       item.setAmount(amount);
     }
   } else if ((slot >= 9 && slot <= 16) || (slot >= 18 && slot <= 25)) {
     if (((TradingPlayerShopkeeper) shopkeeper).clickedItem != null) {
       // placing item
       final Inventory inventory = event.getInventory();
       Bukkit.getScheduler()
           .runTaskLater(
               ShopkeepersPlugin.getInstance(),
               new Runnable() {
                 public void run() {
                   inventory.setItem(slot, ((TradingPlayerShopkeeper) shopkeeper).clickedItem);
                   ((TradingPlayerShopkeeper) shopkeeper).clickedItem = null;
                 }
               },
               1);
     } else {
       // changing stack size
       ItemStack item = event.getCurrentItem();
       if (item != null && item.getType() != Material.AIR) {
         int amount = item.getAmount();
         amount = this.getNewAmountAfterEditorClick(event, amount);
         if (amount <= 0) {
           event.getInventory().setItem(slot, null);
         } else {
           if (amount > item.getMaxStackSize()) amount = item.getMaxStackSize();
           item.setAmount(amount);
         }
       }
     }
   } else if (slot >= 27) {
     // clicking in player inventory
     if (event.isShiftClick() || !event.isLeftClick()) {
       return;
     }
     ItemStack cursor = event.getCursor();
     if (cursor != null && cursor.getType() != Material.AIR) {
       return;
     }
     ItemStack current = event.getCurrentItem();
     if (current != null && current.getType() != Material.AIR) {
       ((TradingPlayerShopkeeper) shopkeeper).clickedItem = current.clone();
       ((TradingPlayerShopkeeper) shopkeeper).clickedItem.setAmount(1);
     }
   } else {
     super.onInventoryClick(event, player);
   }
 }
Example #2
0
  private int findSpace(
      ItemStack item, Map<Integer, StackWithAmount> lookaside, boolean findEmpty) {
    // 1.9.4 and later extend living entity slots beyond 36, but some of these are read-only.
    // We could use .getStorageContents(), but this breaks 1.8.8 compatibility
    int length = (inventory.getHolder() instanceof HumanEntity) ? 36 : inventory.getSize();
    ItemStack[] stacks = Arrays.copyOfRange(inventory.getContents(), 0, length);

    if (item == null) {
      return -1;
    }

    for (int i = 0; i < stacks.length; i++) {
      boolean contains = lookaside.containsKey(i);
      if (findEmpty && !contains) {
        return i;
      } else if (!findEmpty && contains) {
        StackWithAmount compareWith = lookaside.get(i);
        if (compareWith != null) {
          ItemStack compareWithStack = compareWith.getStack();
          if (compareWith.getAmount() < compareWithStack.getMaxStackSize()
              && compareWithStack.isSimilar(item)) {
            return i;
          }
        }
      }
    }

    return -1;
  }
Example #3
0
  /**
   * Returns true is the item stack is not null, if the item is a full sized stack, with size more
   * than one (to prevent simply adding lore to single items), that the item does NOT have lore, and
   * that the item has simple metadata (not a book, fireworks, banners, beacons, other "special"
   * items that generate a host of edge cases like duplication and cheap dye and other problems.)
   *
   * @param is the ItemStack to check validity of compaction
   * @return true if can be compacted, false otherwise
   */
  private boolean canCompact(ItemStack is) {
    return is != null
        && is.getAmount() == is.getMaxStackSize()
        && is.getAmount() > 1
        && !is.getItemMeta().hasLore()
        && is.getItemMeta().getClass().getSuperclass().equals(java.lang.Object.class);

    /* bit of a hack at the end, but effectively only items with "simple" meta, where the implementation
     * is strictly a subclass of Object, and not a subclass of bukkit's CraftMetaItem. */
  }
Example #4
0
  /**
   * Sets the player's current help item amount to the specified value
   *
   * @param player
   * @param amount
   */
  private void moar(Player player, int amount) {
    if (player.getItemInHand().getType() != Material.AIR) {
      ItemStack itemInHand = player.getItemInHand();

      // If amount is too large, set to maxStackSize instead
      int amtToGive = Math.min(amount, itemInHand.getMaxStackSize());
      itemInHand.setAmount(amtToGive);

      // Continue until full amount has been disbursed
      amount -= amtToGive;
      while (amtToGive < amount) {
        amtToGive -= amount;
        player
            .getWorld()
            .dropItemNaturally(
                player.getLocation(),
                new ItemStack(
                    itemInHand.getTypeId(), Math.min(amtToGive, itemInHand.getMaxStackSize())));
      }
    }
  }
 // create/split item stack
 private ItemStack getSplitItemStack(
     int itemRowId, int itemId, short itemDamage, int qty, String enchStr) {
   ItemStack stack = new ItemStack(itemId, qty, itemDamage);
   int maxSize = stack.getMaxStackSize();
   // split stack
   if (qty > maxSize) {
     Connection conn = WebAuctionPlus.dataQueries.getConnection();
     PreparedStatement st = null;
     while (qty > maxSize) {
       try {
         if (WebAuctionPlus.isDebug())
           WebAuctionPlus.log.info(
               "WA Query: getSplitItemStack  qty:"
                   + Integer.toString(qty)
                   + "  max:"
                   + Integer.toString(maxSize));
         st =
             conn.prepareStatement(
                 "INSERT INTO `"
                     + WebAuctionPlus.dataQueries.dbPrefix()
                     + "Items` ( "
                     + "`playerName`, `itemId`, `itemDamage`, `qty`, `enchantments` )VALUES( ?, ?, ?, ?, ? )");
         st.setString(1, playerName);
         st.setInt(2, itemId);
         st.setShort(3, itemDamage);
         st.setInt(4, maxSize);
         st.setString(5, enchStr);
         st.executeUpdate();
       } catch (SQLException e) {
         WebAuctionPlus.log.warning(
             WebAuctionPlus.logPrefix + "Unable to insert new item to inventory!");
         e.printStackTrace();
         return null;
       } finally {
         WebAuctionPlus.dataQueries.closeResources(st, null);
       }
       qty -= maxSize;
     }
     stack.setAmount(qty);
     WebAuctionPlus.dataQueries.closeResources(conn);
   }
   // add enchantments
   if (enchStr != null && !enchStr.isEmpty())
     DataQueries.decodeEnchantments(Bukkit.getPlayer(playerName), stack, enchStr);
   return stack;
 }
Example #6
0
 /** Define a quantidade maxima para o item. */
 public ItemBuilder maxAmount() {
   return amount(item.getMaxStackSize());
 }
 @EventHandler
 public void playerInteract(PlayerInteractEvent event) {
   if (event.isCancelled()) {
     return;
   }
   Player player = event.getPlayer();
   if (player.hasPermission(BannerEditorCommand.PERMISSION)
       && player.getItemInHand().getType().equals(Material.STICK)) {
     BlockState state = event.getClickedBlock().getState();
     if (state instanceof Banner) {
       Banner banner = (Banner) state;
       BannerEditorConfig config = BannerEditorCommand.getPlayerConfig(event.getPlayer());
       BannerEditorMode mode = config.getEditorMode();
       int patternId = config.getPatternId();
       switch (mode) {
         case LIST:
           sendBannerInfoMessage(player, banner);
           break;
         case TEXTURE:
           if (patternId > 0 && patternId <= banner.numberOfPatterns()) {
             banner.setPattern(
                 patternId - 1,
                 new Pattern(
                     banner.getPattern(patternId - 1).getColor(),
                     (PatternType)
                         cycle(banner.getPattern(patternId - 1).getPattern(), event.getAction())));
             banner.update(true, false);
           } else if (patternId == 0) {
             sendNoPattern(player);
           } else {
             sendInvalidPatternId(player, patternId);
           }
           break;
         case COLOR:
           if (patternId > 0 && patternId <= banner.numberOfPatterns()) {
             banner.setPattern(
                 patternId - 1,
                 new Pattern(
                     (DyeColor)
                         cycle(banner.getPattern(patternId - 1).getColor(), event.getAction()),
                     banner.getPattern(patternId - 1).getPattern()));
             banner.update(true, false);
           } else if (patternId == 0) {
             banner.setBaseColor((DyeColor) cycle(banner.getBaseColor(), event.getAction()));
             banner.update(true, false);
           } else {
             sendInvalidPatternId(player, patternId);
           }
           break;
         case ADD:
           banner.addPattern(new Pattern(DyeColor.WHITE, PatternType.CIRCLE_MIDDLE));
           banner.update(true, false);
           break;
         case REMOVE:
           if (patternId > 0 && patternId <= banner.numberOfPatterns()) {
             Pattern pat = banner.removePattern(patternId - 1);
             banner.update(true, false);
           } else if (patternId == 0) {
             sendBaseNoPattern(player);
           } else {
             sendInvalidPatternId(player, patternId);
           }
           break;
         case GET:
           ItemStack item = new ItemStack(Material.BANNER);
           BannerMeta meta = (BannerMeta) item.getItemMeta();
           meta.setBaseColor(banner.getBaseColor());
           for (Pattern pattern : banner.getPatterns()) {
             meta.addPattern(pattern);
           }
           item.setItemMeta(meta);
           int amount = item.getMaxStackSize();
           item.setAmount(amount);
           player.getInventory().addItem(item);
           sendGotBanner(player, amount);
       }
       event.setCancelled(true);
     }
   }
 }
  @Override
  public boolean execute(CommandSender sender, String[] args, Location location) {
    ArrayList<Inventory> inventoryList = new ArrayList<Inventory>();
    if ((args[0].startsWith("@l[") && args[0].endsWith("]"))
        || inventorySubs.containsKey(args[0])) {
      Location invLocation = LogiBlocksMain.parseLocation(args[0], location);
      for (int x = -1; x <= 1; x++) {
        for (int y = -1; y <= 1; y++) {
          for (int z = -1; z <= 1; z++) {
            Block testBlock = invLocation.clone().add(x, y, z).getBlock();
            if (testBlock.getState() instanceof InventoryHolder) {
              inventoryList.add(((InventoryHolder) testBlock.getState()).getInventory());
            }
          }
        }
      }
    } else {
      Player player = Bukkit.getPlayer(args[0]);
      if (player == null) {
        return false;
      }
      inventoryList.add(player.getInventory());
    }
    int subIndex = inventorySubs.containsKey(args[0]) ? 0 : 1;
    if (!inventorySubs.containsKey(args[subIndex])) {
      return false;
    }
    if (inventorySubs.get(args[subIndex]) + subIndex + 1 > args.length) {
      return false;
    }
    for (Inventory inventory : inventoryList) {
      switch (args[subIndex]) {
        case "add":
          for (int i = subIndex + 1; i < args.length; i++) {
            ItemStack item1 = LogiBlocksMain.parseItemStack(args[i]);
            if (item1 == null) {
              continue;
            }
            inventory.addItem(item1);
          }
          break;
        case "remove":
          for (int i = subIndex + 1; i < args.length; i++) {
            ItemStack removeItem = LogiBlocksMain.parseItemStack(args[i]);
            if (removeItem == null) {
              continue;
            }
            for (ItemStack targetItem : inventory.getContents()) {
              if (targetItem == null) {
                continue;
              }
              if (targetItem.isSimilar(removeItem)) {
                if (removeItem.getAmount() > targetItem.getAmount()) {
                  removeItem.setAmount(removeItem.getAmount() - targetItem.getAmount());
                  inventory.remove(removeItem);
                } else {
                  targetItem.setAmount(targetItem.getAmount() - removeItem.getAmount());
                  break;
                }
              }
            }
          }
          break;
        case "removeall":
          for (int i = subIndex + 1; i < args.length; i++) {
            ItemStack removeItem = LogiBlocksMain.parseItemStack(args[i]);
            for (int j = 1; j <= 64; j++) {
              removeItem.setAmount(j);
              inventory.remove(removeItem);
            }
          }
          break;
        case "clear":
          inventory.clear();
          break;
        case "refill":
          for (ItemStack itemStack : inventory.getContents()) {
            if (itemStack == null) {
              continue;
            }
            itemStack.setAmount(
                (args.length > subIndex + 1
                    ? Boolean.parseBoolean(args[subIndex + 1]) ? 64 : itemStack.getMaxStackSize()
                    : itemStack.getMaxStackSize()));
          }
          break;
        case "set":
          int slot = Integer.parseInt(args[subIndex + 1]);
          inventory.setItem(
              slot >= inventory.getSize() ? inventory.getSize() - 1 : slot,
              LogiBlocksMain.parseItemStack(args[subIndex + 2]));
          break;
        case "copy":
          Inventory targetInventory;
          if (args[subIndex + 1].startsWith("@l[") && args[subIndex + 1].endsWith("]")) {
            Block targetBlock =
                LogiBlocksMain.parseLocation(args[subIndex + 1], location).getBlock();
            if (targetBlock.getState() instanceof InventoryHolder) {
              targetInventory = ((InventoryHolder) targetBlock.getState()).getInventory();
            } else {
              return false;
            }
          } else {
            Player player = Bukkit.getPlayer(args[subIndex + 1]);
            if (player == null) {
              return false;
            }
            targetInventory = player.getInventory();
          }
          for (int i = 0; i < inventory.getSize() && i < targetInventory.getSize(); i++) {
            targetInventory.setItem(i, inventory.getItem(i));
          }
          break;
        case "show":
          Player player = Bukkit.getPlayer(args[subIndex + 1]);
          if (player == null) {
            return false;
          }
          if (args.length > subIndex + 2) {
            if (Boolean.parseBoolean(args[subIndex + 2])) {
              Inventory fakeInventory =
                  Bukkit.createInventory(inventory.getHolder(), inventory.getType());
              fakeInventory.setContents(inventory.getContents());
              player.openInventory(fakeInventory);
              return true;
            }
          } else {
            player.openInventory(inventory);
          }
          break;
      }
    }

    return true;
  }
Example #9
0
  public void expandItems(final User user, final List<String> items) throws Exception {
    try {
      IText input = new SimpleTextInput(items);
      IText output = new KeywordReplacer(input, user.getSource(), ess);

      boolean spew = false;
      final boolean allowUnsafe = ess.getSettings().allowUnsafeEnchantments();
      for (String kitItem : output.getLines()) {
        if (kitItem.startsWith(ess.getSettings().getCurrencySymbol())) {
          BigDecimal value =
              new BigDecimal(
                  kitItem.substring(ess.getSettings().getCurrencySymbol().length()).trim());
          Trade t = new Trade(value, ess);
          t.pay(user, OverflowType.DROP);
          continue;
        }

        if (kitItem.startsWith("/")) {
          String command = kitItem.substring(1);
          String name = user.getName();
          command = command.replace("{player}", name);
          Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
          continue;
        }

        final String[] parts = kitItem.split(" +");
        final ItemStack parseStack =
            ess.getItemDb().get(parts[0], parts.length > 1 ? Integer.parseInt(parts[1]) : 1);

        if (parseStack.getType() == Material.AIR) {
          continue;
        }

        final MetaItemStack metaStack = new MetaItemStack(parseStack);

        if (parts.length > 2) {
          // We pass a null sender here because kits should not do perm checks
          metaStack.parseStringMeta(null, allowUnsafe, parts, 2, ess);
        }

        final Map<Integer, ItemStack> overfilled;
        final boolean allowOversizedStacks = user.isAuthorized("essentials.oversizedstacks");
        if (allowOversizedStacks) {
          overfilled =
              InventoryWorkaround.addOversizedItems(
                  user.getBase().getInventory(),
                  ess.getSettings().getOversizedStackSize(),
                  metaStack.getItemStack());
        } else {
          overfilled =
              InventoryWorkaround.addItems(user.getBase().getInventory(), metaStack.getItemStack());
        }
        for (ItemStack itemStack : overfilled.values()) {
          int spillAmount = itemStack.getAmount();
          if (!allowOversizedStacks) {
            itemStack.setAmount(
                spillAmount < itemStack.getMaxStackSize()
                    ? spillAmount
                    : itemStack.getMaxStackSize());
          }
          while (spillAmount > 0) {
            user.getWorld().dropItemNaturally(user.getLocation(), itemStack);
            spillAmount -= itemStack.getAmount();
          }
          spew = true;
        }
      }
      user.getBase().updateInventory();
      if (spew) {
        user.sendMessage(tl("kitInvFull"));
      }
    } catch (Exception e) {
      user.getBase().updateInventory();
      ess.getLogger().log(Level.WARNING, e.getMessage());
      throw new Exception(tl("kitError2"), e);
    }
  }
  @SuppressWarnings("deprecation")
  public Interface_Buy_Sell_Item(
      final List<InventoryInterface> link_Back_Stack,
      Player player,
      Shop shop_,
      final ItemStack itemStack_to_be_bought,
      final int amount,
      boolean deleteable,
      final boolean item_is_bought_without_shop) {
    super(Message_Handler.resolve_to_message(63), 4, link_Back_Stack);
    this.shop = shop_;
    this.setCloseable(false);
    this.amount = amount;
    this.deleteable = deleteable;
    this.itemStack_to_be_bought = itemStack_to_be_bought;

    try {
      this.permissionToBUY = "PrimeShop.Defaults.buyfromShop." + shop.shopname;
      this.permissionToSELL = "PrimeShop.Defaults.sellfromShop." + shop.shopname;
    } catch (Exception e) {
      if (!item_is_bought_without_shop) e.printStackTrace();
      this.permissionToBUY = "PrimeShop.VIP.canBuySellAllItemsRegardlessIfTheyWereAddedToAShop";
      this.permissionToSELL = "PrimeShop.VIP.canBuySellAllItemsRegardlessIfTheyWereAddedToAShop";
    }

    this.setClickHandler(
        new ClickHandler() {
          @Override
          public boolean onClick(
              Player player, ItemStack cursor, ItemStack current, ClickType type) {
            // player.sendMessage("Du hast gedrückt");
            return false;
          }
        });

    // Empty Option
    for (int a = 0; a < this.getWidth(); a++) {
      for (int b = 0; b < this.getHeight(); b++) {
        this.addOption(
            a, b, new Button_with_no_task(Cofiguration_Handler.background_ItemStack, " "));
      }
    }

    // Kaufen

    Button_Buy_Sell_Item buy_Button =
        new Button_Buy_Sell_Item(permissionToBUY, true, 55, itemStack_to_be_bought, "");
    this.addOption(3, 2, buy_Button);
    buy_Button.setDisplayIcon(Cofiguration_Handler.buyButton_ItemStack);
    buy_Button.refresh_price(this.amount);

    // Verkaufen

    Button_Buy_Sell_Item sell_Button =
        new Button_Buy_Sell_Item(permissionToSELL, false, this.amount, itemStack_to_be_bought, "");
    this.addOption(5, 2, sell_Button);
    sell_Button.setDisplayIcon(Cofiguration_Handler.sellButton_ItemStack);
    sell_Button.refresh_price(this.amount);

    if (PrimeShop.has_player_Permission_for_this_Command(player, "PrimeShop.admin.changePrices")) {

      if (this.shop != null) {

        if (PrimeShop.get_all_SubItems_of_ItemStack(itemStack_to_be_bought).isEmpty()
            || PrimeShop.plugin.is_PriceLinking_disabled_for_Item(itemStack_to_be_bought)) {

          // Change Price

          ItemStack currentItem = new ItemStack(Material.getMaterial(266));
          this.addOption(
              8,
              2,
              new Button(
                  currentItem.getType(),
                  currentItem.getData().getData(),
                  Message_Handler.resolve_to_message(22),
                  Message_Handler.resolve_to_message(125)) {

                @Override
                public void onClick(
                    InventoryInterface inventoryInterface,
                    Player player,
                    ItemStack cursor,
                    ItemStack current,
                    ClickType type) {
                  PrimeShop.close_InventoyInterface(player);
                  PrimeShop.databaseHandler.link_with_Databse_if_not_allready_linked(
                      PrimeShop.get_Shop_Item_of_Itemstack(itemStack_to_be_bought));
                  PrimeShop.open_InventoyInterface(
                      player,
                      new Interface_Change_Price(
                          inventoryInterface.branch_back_Stack,
                          player,
                          itemStack_to_be_bought.clone()));
                }
              });

          // Changing Rate

          currentItem = new ItemStack(Material.getMaterial(66));
          this.addOption(
              8,
              1,
              new Button(
                  currentItem.getType(),
                  currentItem.getData().getData(),
                  Message_Handler.resolve_to_message(24),
                  Message_Handler.resolve_to_message(124)) {

                @Override
                public void onClick(
                    InventoryInterface inventoryInterface,
                    Player player,
                    ItemStack cursor,
                    ItemStack current,
                    ClickType type) {
                  if (Cofiguration_Handler.dynamic_pricing_for_all_Items_DISABLED) {
                    player.sendMessage(
                        ChatColor.RED + "Dynamic pricing is disabled in the config.yml!");
                    return;
                  }
                  PrimeShop.close_InventoyInterface(player);
                  PrimeShop.databaseHandler.link_with_Databse_if_not_allready_linked(
                      PrimeShop.get_Shop_Item_of_Itemstack(itemStack_to_be_bought));
                  PrimeShop.open_InventoyInterface(
                      player,
                      new Interface_Change_Rate(
                          inventoryInterface.branch_back_Stack,
                          player,
                          itemStack_to_be_bought.clone()));
                }
              });
        } else {

          // List all SubItems

          this.addOption(
              8,
              2,
              new Button(
                  Material.getMaterial(14),
                  (short) 1,
                  Message_Handler.resolve_to_message(49),
                  Message_Handler.resolve_to_message(50),
                  Message_Handler.resolve_to_message(51)) {

                @Override
                public void onClick(
                    InventoryInterface inventoryInterface,
                    Player player,
                    ItemStack cursor,
                    ItemStack current,
                    ClickType type) {

                  PrimeShop.close_InventoyInterface(player);
                  PrimeShop.open_InventoyInterface(
                      player,
                      new Interface_List_of_Subitems(
                          inventoryInterface.branch_back_Stack,
                          itemStack_to_be_bought,
                          shop,
                          player));
                }
              });
        }
        // Enable PriceLinking

        if (PrimeShop.plugin.is_PriceLinking_disabled_for_Item(itemStack_to_be_bought)) {

          addOption(
              7,
              3,
              new Button(
                  Material.ANVIL,
                  Message_Handler.resolve_to_message(52),
                  Message_Handler.resolve_to_message(53)) {

                @Override
                public void onClick(
                    InventoryInterface inventoryInterface,
                    Player player,
                    ItemStack cursor,
                    ItemStack current,
                    ClickType type) {

                  if (PrimeShop.plugin.is_PriceLinking_disabled_for_Item(itemStack_to_be_bought)) {

                    PrimeShop.plugin.enable_PriceLinking_for_Item(itemStack_to_be_bought);
                    PrimeShop.close_InventoyInterface(player);
                    PrimeShop.open_InventoyInterface(
                        player,
                        inventoryInterface.branch_back_Stack.get(
                            inventoryInterface.position_in_Stack - 1));
                  }
                }
              });
        }
      }
      if (shop_ != null) {
        if (PrimeShop.has_player_Permission_for_this_Command(
            player, "PrimeShop.admin.addItemsToShop." + shop_.shopname)) {

          // Remove Item from Shop

          if (deleteable) {
            this.addOption(
                8,
                3,
                new Button(
                    Material.WOOL,
                    (short) 14,
                    Message_Handler.resolve_to_message(54),
                    Message_Handler.resolve_to_message(55),
                    "") {

                  @Override
                  public void onClick(
                      InventoryInterface inventoryInterface,
                      Player player,
                      ItemStack cursor,
                      ItemStack current,
                      ClickType type) {

                    PrimeShop.close_InventoyInterface(player);
                    PrimeShop.open_InventoyInterface(
                        player,
                        new Interface_delete_Item_from_Shop(
                            inventoryInterface.branch_back_Stack,
                            player,
                            itemStack_to_be_bought,
                            shop));
                  }
                });
          }
        }
      }
    }

    // Display Icon
    if (itemStack_to_be_bought.getMaxStackSize() > 1) {
      Button_Amount button_Amount =
          new Button_Amount(
              itemStack_to_be_bought,
              "",
              Message_Handler.resolve_to_message(56),
              Message_Handler.resolve_to_message(57),
              Message_Handler.resolve_to_message(58),
              Message_Handler.resolve_to_message(59));
      button_Amount.setAmount(this.amount);
      this.addOption(4, 0, button_Amount);
    } else {
      this.addOption(
          4,
          0,
          new Button_with_no_task(
              itemStack_to_be_bought,
              "",
              Message_Handler.resolve_to_message(
                  56, PrimeShop.convert_IemStack_to_DisplayName(itemStack_to_be_bought)),
              Message_Handler.resolve_to_message(60)));
    }

    // Close Option
    this.addOption(8, 0, new Button_close_Interface());

    // Go Back Option
    if (!item_is_bought_without_shop) {
      if (position_in_Stack > 0) {

        this.addOption(
            0,
            0,
            new Button(
                shop.displayIcon,
                Message_Handler.resolve_to_message(61),
                Message_Handler.resolve_to_message(62)) {

              @Override
              public void onClick(
                  InventoryInterface inventoryInterface,
                  Player player,
                  ItemStack cursor,
                  ItemStack current,
                  ClickType type) {
                PrimeShop.close_InventoyInterface(player);
                PrimeShop.open_InventoyInterface(
                    player, inventoryInterface.branch_back_Stack.get(position_in_Stack - 1));
              }
            });
      }
    }
  }