private SmeltingRecipe GetSmeltingRecipe(ItemInventory item) { SmeltingRecipe recipe = null; if (item != null && !ItemHelper.IsVoid(item)) recipe = SmeltingRecipe.GetRecipe(Server.GetSmeltingRecipes(), item); return recipe; }
private bool MatchesUnordered(ItemInventory[] ingredients) { foreach (var ing1 in Ingredients2) { foreach (var ing2 in ingredients) { if (ing1.Type == ing2.Type && (ing1.Durability < 0 || ing1.Durability == ing2.Durability) && ing2.Count >= ing1.Count) goto continue1; continue; } return false; continue1: continue; } foreach (var ing1 in ingredients) { foreach (var ing2 in Ingredients2) { if (ing1.Type == ing2.Type && (ing1.Durability < 0 || ing1.Durability == ing2.Durability) && ing2.Count >= ing1.Count) goto continue2; continue; } return false; continue2: continue; } return true; }
private bool MatchesOrdered(ItemInventory[] ingredients) { int s = ingredients.Length == 4 ? 2 : 3; int dw = s - Ingredients3.GetLength(1); int dh = s - Ingredients3.GetLength(0); for (int w = 0; w <= dw; w++) { for (int h = 0; h <= dh; h++) { for (int x = w; x < w + Ingredients3.GetLength(1); x++) { for (int y = h; y < h + Ingredients3.GetLength(0); y++) { var ing1 = Ingredients3[y - h, x - w]; var ing2 = ingredients[y * s + x]; if (ItemHelper.IsVoid(ing1) && ItemHelper.IsVoid(ing2)) continue; if (ing1.Type == ing2.Type && (ing1.Durability < 0 || ing1.Durability == ing2.Durability) && ing2.Count >= ing1.Count) continue; goto continue1; } } return true; continue1: continue; } } return false; }
public static SmeltingRecipe GetRecipe(SmeltingRecipe[] recipes, ItemInventory ingredient) { foreach (SmeltingRecipe r in recipes) { if (r.Ingredient.StacksWith(ingredient)) return r; } return null; }
private Recipe(ItemInventory result, ItemInventory[,] ingredients, ItemInventory[,] products, bool anyOrder) { Ingredients3 = ingredients; Result = result; Products = products; AnyOrder = anyOrder; var ings = new List<ItemInventory>(); for (int h = 0; h < ingredients.GetLength(0); h++) for (int w = 0; w < ingredients.GetLength(1); w++) if (ingredients[h, w] != null && !ItemHelper.IsVoid(ingredients[h, w])) ings.Add(ingredients[h, w]); Ingredients2 = ings.ToArray(); }
public override void Read(PacketReader stream) { WindowId = stream.ReadSByte(); Slot = stream.ReadShort(); Item = ItemHelper.GetInstance(stream); }
public override void Read(PacketReader stream) { WindowId = stream.ReadSByte(); Slot = stream.ReadShort(); MouseButton = (MouseButtonClicked)stream.ReadByte(); Transaction = stream.ReadShort(); Mode = (ClickWindowMode)stream.ReadByte(); Item = ItemHelper.GetInstance(stream); }
public override void ChangeSlot(sbyte senderWindowId, short slot, ItemInventory newItem) { base.ChangeSlot(senderWindowId, slot, newItem); StartBurning(); }
private void AddOutput() { if (!ItemHelper.IsVoid(OutputSlot)) { //OutputSlot = new ItemStack(OutputSlot.Type, ++OutputSlot.Count, OutputSlot.Durability); OutputSlot.Count++; return; } ItemInventory output = GetSmeltingRecipe(InputSlot).Result; output.Count = 1; OutputSlot = output; }
/// <summary> /// This ensures that we are matching the correct number of ingredients (e.g. two separate blocks of wood, not three). Fixes #69 (https://www.assembla.com/spaces/chraft/tickets/69-recipies-do-not-evaluate-full-recipe--they-select-first-found). /// </summary> /// <param name="ingredients">ingredients to count</param> /// <returns>true if the number of individual ingredients match</returns> private bool MatchesIngredientsCount(ItemInventory[] ingredients) { return (Ingredients2.Length - CountVoidIngredients(Ingredients2)) == (ingredients.Length - CountVoidIngredients(ingredients)); }
public static Recipe[] FromFile(string file) { string[] lines = File.ReadAllLines(file); List<List<string>> recs = new List<List<string>>(); for (int i = 0; i < lines.Length; i++) { string l = lines[i]; if (!l.StartsWith("[") || !l.EndsWith("]")) continue; List<string> rec = new List<string>(); while (i < lines.Length && lines[i] != "" && lines[i] != "=") rec.Add(lines[i++]); recs.Add(rec); } List<Recipe> recipes = new List<Recipe>(); foreach (List<string> r in recs) { bool anyOrder = r[0].StartsWith("[[") && r[0].EndsWith("]]"); var result = ItemHelper.Parse(r[0].Trim('[', ']')); r.RemoveAt(0); int height = r.Count; int width = r[0].Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries).Length; var ing = new ItemInventory[height, width]; for (int h = 0; h < height; h++) { string[] items = r[h].Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries); for (int w = 0; w < width; w++) ing[h, w] = ItemHelper.Parse(items[w]); } recipes.Add(new Recipe(result, ing, new ItemInventory[3, 3], anyOrder)); } return recipes.ToArray(); }
public static Recipe[] FromXmlFile(string file) { // Define variables List<Recipe> loadedRecipes = new List<Recipe>(); XDocument document; // Load the recipes file document = XDocument.Load(file); // Get all of the recipe elements var recipes = document.Descendants("Recipes").Descendants("Recipe"); // Loop through the recipe elements foreach (XElement recipe in recipes) { // Define variables ItemInventory result; ItemInventory[,] ingredients; bool freeformRecipe = false; int rowCount = 0, row = 0; // Determine the resulting item string amount = recipe.Descendants("Amount").First().Value; string id = recipe.Attribute("Id").Value; // - Create the stack result = ItemHelper.Parse(string.Format("{0}#{1}", id, amount)); // Determine whether or not this is a free-from recipe string match = recipe.Attribute("Match").Value; // - Check the value if (match.ToLower() == "any") freeformRecipe = true; // Load the rows var rows = recipe.Descendants("Rows").Descendants("Row"); rowCount = rows.Count<XElement>(); // Initialize the ingredients array ingredients = new ItemInventory[rowCount, 3]; // Loop through the row elements foreach (XElement r in rows) { // Define variables string value = r.Value; string[] items = value.Split(','); // Loop through the items for (int i = 0; i < items.Length; i++) { // Define variables string item = items[i]; // Add the item stack to the ingredients list ingredients[row, i] = ItemHelper.Parse(item); } // Increment the row variable row++; } // Add the recipe to the list loadedRecipes.Add(new Recipe(result, ingredients, new ItemInventory[3, 3], freeformRecipe)); } // Return the loaded recipes return loadedRecipes.ToArray(); }
public static Recipe GetRecipe(Recipe[] recipes, ItemInventory[] ingredients) { foreach (Recipe r in recipes) { if (r.Matches(ingredients)) return r; } return null; }
/// <summary> /// Subtracts the ingredients that are required to craft this recipe, by updating the ingredient.Count property /// </summary> /// <param name="ingredients">The ingredients to be used</param> public void UseIngredients(ItemInventory[] ingredients) { // Assumption: // Recipes ingredients are loaded left to right, top to bottom, which is the same order of workbench/inventory recipe slots // e.g. 1 2 <- inventory // 3 4 //------------- // 1 2 3 <- workbench // 4 5 6 // 7 8 9 int indx = 0; foreach (var item in this.Ingredients2) { // Based on assumption about load order: simply getting the next non-void ingredient will match the current recipe ingredient, then subtract the number required. for (int i = indx; i < ingredients.Length; i++) { if (!ItemHelper.IsVoid(ingredients[i])) { ingredients[i].Count -= item.Count; indx = i + 1; break; } } } }
/// <summary> /// Counts the number of ingredients that are Void items /// </summary> /// <param name="ingredients"></param> /// <returns>The number of ItemStack.IsVoid() ingredients</returns> private int CountVoidIngredients(ItemInventory[] ingredients) { int result = 0; foreach (var item in ingredients) { if (ItemHelper.IsVoid(item)) result++; } return result; }
public override void Read(PacketReader stream) { EntityId = stream.ReadInt(); Slot = stream.ReadShort(); Item = ItemHelper.GetInstance(stream); }
private SmeltingRecipe(ItemInventory result, ItemInventory ingredient) { Ingredient = ingredient; Result = result; }
public virtual void ChangeSlot(sbyte senderWindowId, short slot, ItemInventory newItem) { Slots[slot] = newItem; foreach (var persistentInterface in Interfaces) if (persistentInterface.Handle != senderWindowId) persistentInterface[slot] = newItem; Save(); }
public static bool IsVoid(ItemInventory item) { return (item == null || item.Type == -1 || item.Count < 1); }
private bool Matches(ItemInventory[] ingredients) { // 1. check that the correct number of ingredients exist (quickly excludes any recipes of differing number of ingredients) // fixes #69: "Recipies do not evaluate full recipe, they select first found" if (MatchesIngredientsCount(ingredients)) { // 2. now do the check for whether this recipe matches the provided ingredients return AnyOrder ? MatchesUnordered(ingredients) : MatchesOrdered(ingredients); } else { return false; } }