LINQ 查询比较两个列表与子列表

Question

I'm making a game that has a crafting system. I'm trying to get a list of recipes, but only show the ones the player has enough of in their inventory. I'm having difficulty figuring out this query. Here are my stripped down classes:

public class GameItem
{
    public string itemName;
    public int quantityHeld;
}

public class GameItemRecipe : GameItem
{
    public GameItemIngredient[] giiIngredients;
}

public class GameItemIngredient : GameItem
{        
    public int quantityNeeded;
}

So I have a list of GameItems; that is the player's inventory. Then I have a separate list of Recipes that the Player knows. The Recipes have a sub list of the ingredients required to make it. So I want to get the list of recipes that have enough items in the inventory. Any help is appreciated.

Answer 1

var recipes = new List<GameItemRecipe>();
var inventory = new List<GameItem>();

var possibleRecipes = recipes.Where(rec => r.giiIngredients.
                          All(i => ing.quantityNeeded <= inventory.
                          FirstOrDefault(gi => gi.itemName== ing.itemName)?.quantityHeld));

This query takes all of your recipes, where for all of the ingredients the quantity need field is smaller or equals the quanitity held field of the game item with the same item name in your inventory lsit of game items.

Answer 2

So you have a Player , and this Player has an Inventory , which is a sequence of GameItems . Some of these GameItems may be GameItemIngredients . You didn't specify that all GameItems in the Inventory are GameItemIngredients, so it might be that some GameItems in the Inventory are not GameItemIngredients.

Furthermore, the Player knows a sequence of GameItemRecipes . To make one of these recipes, the player needs the GameItemIngredients that are mentioned in the recipe.

The Player needs to know which Recipes he can make. In other words: for which Recipes does the Player have enough Ingredients.

IEnumerable<GameItem> inventory = ...
IEnumerable<GameItemRecipe> recipes = ...

From this you can extract all Ingredients that the Player has in his Inventory:

IEnumerable<GameItemIngredient> ingredients = inventory.OfType<GameItemRecipe>();

Requirement: Give me all Recipes that the Player can make; which are all Recipes that the Player has all Ingredients for.

Every GameItemIngredient has a property RequiredQuantity . I assume that every Recipe will have unique names for the GameItemIngredients that are needed to make the Recipe.

Simply said: if you need two Potatoes to make Recipe "Mashed Potatoes", then the Ingredients list of the Recipe will contain only one Ingredient with the Name "Potato". This Ingredient will have quantity 2. So you will not have the Ingredient Potato twice in your Recipe.

Furthermore I assume, that you don't do sub-classing in your Recipes: if your Recipe requires an "Apple", and you have a "Granny Smith" in your Inventory, then alas, you can't make the Recipe, even though a "Granny Smith" is an "Apple".

A Recipe can be made, if all Ingredients of the Recipe are in the Ingredients of the Inventory AND the QuantityNeeded <= QuantityHeld .

So for every Recipe we will need to check whether the Ingredients are in the Inventory. To make this efficient, we will make a Dictionary of the Ingredients that are in the Inventory. Key is the ItemName of the Ingredient; Value is the QuantityHeld

var ingredientQuantities = ingredients.ToDictionary(
    ingredient => ingredient.ItemName,
    ingredient => ingredient.QuantityHeld);

Consider to use an EqualityComparer if "Apple" is the same ingredient as "apple"

The ItemName of every ingredient of a Recipe should be a key in the Dictionary, AND the QuantityNeeded <= QuantityHeld (= value in the Dictionary)

var recipesThatCanBeMade = recipes
   .Where(recipe => !recipe.Ingredients.All(ingredient =>
       ingredientQuantities.TryGetValue(ingredient.ItemName, out int quantityHeld)
       && ingredient.QuantityNeeded <= quantityHeld)

In words: from every recipe in the sequence of recipes, keep only those recipes where

• ALL ingredients have an ItemName that is a key in the dictionary,
• AND have a QuantityNeeded that is smaller or equal to the QuantityHeld that is the corresponding value in the Dictionary.