/**
   * Merges lines on a sign into a single line for processing, when the direction on the lines
   * match. Needed for support of the '!' character.
   */
  public static ArrayList<String> getItemLines(Sign sign) {
    HashMap<CompassDirection, String> directions = new HashMap<CompassDirection, String>(5);
    ArrayList<String> lines = new ArrayList<String>(3);
    for (int line = 1; line < 4; line++) {
      String text = StringUtils.removeBrackets(sign.getLine(line)).trim();
      if (!text.isEmpty() && !isFurnaceFuelLine(text) && !isFurnaceSmeltLine(text)) {
        CompassDirection direction = ItemUtils.getLineItemDirection(text);
        if (!directions.containsKey(direction)) {
          directions.put(direction, text);
        } else {
          String format = text;
          if (direction != CompassDirection.NO_DIRECTION) {
            format = format.substring(2);
          }
          directions.put(direction, directions.get(direction) + ":" + format);
        }
      }
    }

    MinecartManiaLogger.getInstance().debug("Merged Item Strings");
    Iterator<Entry<CompassDirection, String>> i = directions.entrySet().iterator();
    while (i.hasNext()) {
      Entry<CompassDirection, String> entry = i.next();
      lines.add(entry.getValue());
      MinecartManiaLogger.getInstance().debug("Item String: " + entry.getValue());
    }
    return lines;
  }
Ejemplo n.º 2
0
 public static void addParserAlias(
     final String aliasName, final ArrayList<SpecificMaterial> values) {
   // Create a new ItemMatcher
   final ItemMatcher matcher = new ItemMatcher();
   // Make a new OR statement
   final MatchOR or = new MatchOR();
   for (final SpecificMaterial mat : values) {
     final MatchConstant type = new MatchConstant(MatchField.TYPE_ID, mat.id);
     if (mat.durability != -1) {
       // Create a new constant token and add it to an AND
       // This basically becomes "... || (typeID=={whatever} && data=={whatever}
       final MatchAND and = new MatchAND();
       and.addExpression(type);
       and.addExpression(new MatchConstant(MatchField.DURABILITY, mat.durability));
       or.addExpression(and);
     } else {
       or.addExpression(type);
     }
   }
   matcher.addExpression(or);
   ItemUtils.addParserAlias(aliasName, matcher);
 }
  public static void doCrafting(final MinecartManiaStorageCart minecart) {
    // Efficiency. Don't process overlapping tiles repeatedly, waste of time
    final int interval =
        minecart.getDataValue("Craft Interval") == null
            ? -1
            : (Integer) minecart.getDataValue("Craft Interval");
    if (interval > 0) {
      minecart.setDataValue("Craft Interval", interval - 1);
    } else {
      minecart.setDataValue("Craft Interval", minecart.getRange() / 2);
      final HashSet<Block> blockList = minecart.getAdjacentBlocks(minecart.getRange());
      for (final Block block : blockList) {
        if (block.getTypeId() == Material.WORKBENCH.getId()) {
          final ArrayList<Sign> signList =
              SignUtils.getAdjacentMinecartManiaSignList(block.getLocation(), 2);
          for (final Sign sign : signList) {
            if (sign.getLine(0).toLowerCase().contains("craft items")) {
              sign.setLine(0, "[Craft Items]");
              // For each line on the sign
              String itemListString = "";
              for (int i = 1; i < sign.getNumLines(); i++) {
                if (i > 1) {
                  itemListString += ":";
                }
                itemListString += sign.getLine(i);
              }
              for (final SpecificMaterial item :
                  ItemUtils.getItemStringListToMaterial(itemListString.split(":"))) {
                // Get the recipe, if possible
                final RecipeData recipe = RecipeManager.findRecipe(item);

                if (recipe == null) {
                  continue; // Skip if we can't find it.
                }
                if ((recipe.ingredients == null) || (recipe.ingredients.size() == 0)) {
                  continue;
                }

                boolean outOfIngredients = false;

                int loops = 0;

                final List<ItemStack> fixedIngredients = new ArrayList<ItemStack>();

                debug(
                    minecart,
                    "RECIPE: "
                        + recipe.results.toString()
                        + " (d: "
                        + recipe.results.getDurability()
                        + ")");
                // Until we're out of ingredients, or the loop has been executed 64 times.
                while (!outOfIngredients && (loops < 64)) {
                  fixedIngredients.clear();

                  loops++;
                  // Loop through the list of ingredients for this recipe
                  for (final ItemStack stack : recipe.ingredients) {
                    boolean found = false;

                    if (stack.getDurability() == (short) -1) {
                      // See what we have
                      ItemStack subitem = null;
                      for (int is = 0; is < minecart.size(); is++) {
                        final ItemStack si = minecart.getItem(is);
                        if ((si != null) && (si.getTypeId() == stack.getTypeId())) {
                          subitem = si;
                          break;
                        }
                      }
                      if (subitem == null) {
                        continue;
                      }
                      stack.setDurability(subitem.getDurability());

                      // See if we have the needed ingredient
                      final int num = minecart.amount(stack.getTypeId(), stack.getDurability());
                      if (minecart.amount(stack.getTypeId(), stack.getDurability())
                          < stack.getAmount()) {
                        continue;
                      } else {
                        debug(
                            minecart,
                            "Cart has "
                                + num
                                + " "
                                + recipe.results.toString()
                                + " (d: "
                                + recipe.results.getDurability()
                                + ")!");
                        found = true;
                        break;
                      }
                    } else {
                      if (stack.getDurability() == -1) {
                        stack.setDurability((short) 0);
                      }

                      // See if we have the needed ingredients
                      if (minecart.amount(stack.getTypeId(), stack.getDurability())
                          >= stack.getAmount()) {
                        found = true;
                      } else {
                        debug(
                            minecart,
                            "OOI: " + stack.toString() + " (d: " + stack.getDurability() + ")");
                        outOfIngredients = true;
                        break;
                      }
                    }
                    if (!found) {
                      outOfIngredients = true;
                      debug(
                          minecart,
                          "OOI: " + stack.toString() + " (d: " + stack.getDurability() + ")");
                      break;
                    } else {
                      // debug(minecart, "Ingredient found: " + stack.toString() + " (d: " +
                      // stack.getDurability() + ")");
                      fixedIngredients.add(stack);
                    }
                  }

                  if (outOfIngredients) {
                    break;
                  }

                  // Double-check
                  debug(
                      minecart,
                      "Recipe for "
                          + recipe.results.toString()
                          + " (d: "
                          + recipe.results.getDurability()
                          + ")");
                  for (final ItemStack stack : fixedIngredients) {
                    if (minecart.canRemoveItem(
                        stack.getTypeId(), stack.getAmount(), stack.getDurability())) {
                      debug(
                          minecart,
                          " + " + stack.toString() + " (d: " + stack.getDurability() + ")");
                    } else {
                      debug(
                          minecart,
                          "OOI: " + stack.toString() + " (d: " + stack.getDurability() + ")");
                      outOfIngredients = true;
                      break;
                    }
                  }

                  if (outOfIngredients) {
                    break;
                  }

                  if (!minecart.canAddItem(recipe.results)) {
                    debug(minecart, "CAI: " + recipe.results.toString());
                    outOfIngredients = true;
                    break;
                  }

                  // Loop through again to actually remove the items
                  for (final ItemStack stack : fixedIngredients) {
                    debug(
                        minecart,
                        "[Craft Items] Removed "
                            + stack.toString()
                            + " (d: "
                            + stack.getDurability()
                            + ") from minecart!");
                    minecart.removeItem(
                        stack.getTypeId(), stack.getAmount(), stack.getDurability());
                  }
                  // Take it from the cart
                  minecart.addItem(recipe.results);
                  debug(
                      minecart,
                      "[Craft Items] Added " + recipe.results.toString() + " to minecart!");
                }
              }
            }
          }
        }
      }
    }
  }
 public MinimumItemAction(Sign sign) {
   this.items = ItemUtils.getItemStringListToMaterial(sign.getLines());
 }