Merge pull request #39 from ManualForArchipelago/item_with_values

Add logic for item with values

Author: FuzzyGamesOn

schemas/Manual.items.schema.json

@@ -57,6 +57,20 @@
                 "type": "boolean",
                 "default": true
             },
+            "value": {
+                "description": "(Optional) A dictonary of values this item has in the format {\"name\": int,\"otherName\": int} \nUsed with the {ItemValue(Name: int)} in location requires \neg. \"value\": {\"coins\":10} mean this item is worth 10 coins",
+                "type": "object",
+                "patternProperties": {
+                    "^.+$": {
+                        "anyOf": [
+                            {
+                                "type": "integer",
+                                "description": "A value that this item has must be 'name':integer \neg. \"coins\": 10"
+                            }
+                        ]
+                    }
+                }
+            },
             "_comment": {"$ref": "#/definitions/comment"}
 
         },

src/DataValidation.py

@@ -1,6 +1,9 @@
 import logging
 import re
 import json
+from worlds.AutoWorld import World
+from BaseClasses import MultiWorld, ItemClassification
+
 
 class ValidationError(Exception):
     pass
@@ -192,6 +195,109 @@ def checkItemsThatShouldBeRequired():
                     if item["name"] in region_requires:
                         raise ValidationError("Item %s is required by region %s, but the item is not marked as progression." % (item["name"], region_name))
 
+    @staticmethod
+    def _checkLocationRequiresForItemValueWithRegex(values_requested: dict[str, int], requires) -> dict[str, int]:
+        if isinstance(requires, str) and 'ItemValue' in requires:
+            for result in re.findall(r'\{ItemValue\(([^:]*)\:([^)]+)\)\}', requires):
+                value = result[0].lower().strip()
+                count = int(result[1])
+                if not values_requested.get(value):
+                    values_requested[value] = count
+                else:
+                    values_requested[value] = max(values_requested[value], count)
+        return values_requested
+
+    @staticmethod
+    def checkIfEnoughItemsForValue():
+        values_available = {}
+        values_requested = {}
+
+        # First find the biggest values required by locations
+        for location in DataValidation.location_table:
+            if "requires" not in location:
+                continue
+
+            # convert to json so we don't have to guess the data type
+            location_requires = json.dumps(location["requires"])
+
+            DataValidation._checkLocationRequiresForItemValueWithRegex(values_requested, location_requires)
+        # Second, check region requires for the presence of item name
+        for region_name in DataValidation.region_table:
+            region = DataValidation.region_table[region_name]
+
+            if "requires" not in region:
+                continue
+
+            # convert to json so we don't have to guess the data type
+            region_requires = json.dumps(region["requires"])
+
+            DataValidation._checkLocationRequiresForItemValueWithRegex(values_requested, region_requires)
+        # then if something is requested, we loop items
+        if values_requested:
+
+            # get all the available values with total count
+            for item in DataValidation.item_table:
+                # if the item is already progression, no need to check
+                if not item.get("progression") and not item.get("progression_skip_balancing"):
+                    continue
+
+                item_count = item.get('count', None)
+                if item_count is None: #check with none because 0 == false
+                    item_count = '1'
+
+                for key, count in item.get("value", {}).items():
+                    if not values_available.get(key.lower().strip()):
+                        values_available[key] = 0
+                    values_available[key] += int(count) * int(item_count)
+
+            # compare whats available vs requested
+            errors = []
+            for value, count in values_requested.items():
+                if values_available.get(value, 0) < count:
+                    errors.append(f"   '{value}': {values_available.get(value, 0)} out of the {count} {value} worth of progression items required can be found.")
+            if errors:
+                raise ValidationError("There are not enough progression items for the following values: \n" + "\n".join(errors))
+
+    @staticmethod
+    def preFillCheckIfEnoughItemsForValue(world: World, multiworld: MultiWorld):
+        from .Helpers import get_items_with_value, get_items_for_player
+        player = world.player
+        values_requested = {}
+
+        for region in multiworld.regions:
+            if region.player != player:
+                continue
+
+            manualregion = DataValidation.region_table.get(region.name, {})
+            if "requires" in manualregion and manualregion["requires"]:
+                region_requires = json.dumps(manualregion["requires"])
+
+                DataValidation._checkLocationRequiresForItemValueWithRegex(values_requested, region_requires)
+
+            for location in region.locations:
+                manualLocation = world.location_name_to_location.get(location.name, {})
+                if "requires" in manualLocation and manualLocation["requires"]:
+                    DataValidation._checkLocationRequiresForItemValueWithRegex(values_requested, manualLocation["requires"])
+
+        # compare whats available vs requested but only if there's anything requested
+        if values_requested:
+            errors = []
+            existing_items = [item for item in get_items_for_player(multiworld, player) if item.code is not None and
+                        item.classification == ItemClassification.progression or item.classification == ItemClassification.progression_skip_balancing]
+
+            for value, val_count in values_requested.items():
+                items_value = get_items_with_value(world, multiworld, value, player, True)
+                found_count = 0
+                if items_value:
+                    for item in existing_items:
+                        if item.name in items_value:
+                            found_count += items_value[item.name]
+
+                if found_count < val_count:
+                    errors.append(f"   '{value}': {found_count} out of the {val_count} {value} worth of progression items required can be found.")
+            if errors:
+                raise ValidationError("There are not enough progression items for the following value(s): \n" + "\n".join(errors))
+
     @staticmethod
     def checkRegionsConnectingToOtherRegions():
         for region_name in DataValidation.region_table:
@@ -338,7 +444,16 @@ def checkForNonStartingRegionsThatAreUnreachable():
                 raise ValidationError("The region '%s' is set as a non-starting region, but has no regions that connect to it. It will be inaccessible." % nonstarter)
 
 
+def runPreFillDataValidation(world: World, multiworld: MultiWorld):
+    validation_errors = []
 
+    # check if there is enough items with values
+    try: DataValidation.preFillCheckIfEnoughItemsForValue(world, multiworld)
+    except ValidationError as e: validation_errors.append(e)
+
+    if validation_errors:
+        newline = "\n"
+        raise Exception(f"\nValidationError(s) for pre_fill of player {world.player}: \n\n{newline.join([' - ' + str(validation_error) for validation_error in validation_errors])}\n\n")
 # Called during stage_assert_generate
 def runGenerationDataValidation() -> None:
     validation_errors = []
@@ -358,6 +473,10 @@ def runGenerationDataValidation() -> None:
     try: DataValidation.checkItemsThatShouldBeRequired()
     except ValidationError as e: validation_errors.append(e)
 
+    # check if there's enough Items with values to get to every location requesting it
+    try: DataValidation.checkIfEnoughItemsForValue()
+    except ValidationError as e: validation_errors.append(e)
+
     # check that regions that are connected to are correct
     try: DataValidation.checkRegionsConnectingToOtherRegions()
     except ValidationError as e: validation_errors.append(e)

src/Helpers.py

@@ -1,4 +1,6 @@
-from BaseClasses import MultiWorld
+from BaseClasses import MultiWorld, Item
+from typing import Optional, List
+from worlds.AutoWorld import World
 from .Data import category_table
 from .Items import ManualItem
 from .Locations import ManualLocation
@@ -85,4 +87,36 @@ def _is_manualobject_enabled(multiworld: MultiWorld, player: int, object: any) -
             enabled = False
             break
 
-    return enabled
+    return enabled
+
+def get_items_for_player(multiworld: MultiWorld, player: int) -> List[Item]:
+    """Return list of items of a player including placed items"""
+    return [i for i in multiworld.get_items() if i.player == player]
+
+def get_items_with_value(world: World, multiworld: MultiWorld, value: str, player: Optional[int] = None, force: bool = False) -> dict[str, int]:
+    """Return a dict of every items with a specific value type present in their respective 'value' dict\n
+    Output in the format 'Item Name': 'value count'\n
+    Keep a cache of the result and wont redo unless 'force == True'
+    """
+    if player is None:
+        player = world.player
+
+    player_items = get_items_for_player(multiworld, player)
+    # Just a small check to prevent caching {} if items don't exist yet
+    if not player_items:
+        return {value: -1}
+
+    value = value.lower().strip()
+
+    if not hasattr(world, 'item_values'): #Cache of just the item values
+        world.item_values = {}
+
+    if not world.item_values.get(player):
+        world.item_values[player] = {}
+
+    if value not in world.item_values.get(player, {}).keys() or force:
+        item_with_values = {i.name: world.item_name_to_item[i.name]['value'].get(value, 0)
+                            for i in player_items if i.code is not None
+                            and i.name in world.item_name_groups.get(f'has_{value}_value', [])}
+        world.item_values[player][value] = item_with_values
+    return world.item_values[player].get(value)

src/Items.py

@@ -42,6 +42,12 @@
             item_name_groups[c] = []
         item_name_groups[c].append(item_name)
 
+    for v in item.get("value", {}).keys():
+        group_name = f"has_{v.lower().strip()}_value"
+        if group_name not in item_name_groups:
+            item_name_groups[group_name] = []
+        item_name_groups[group_name].append(item_name)
+
 item_id_to_name[None] = "__Victory__"
 item_name_to_id = {name: id for id, name in item_id_to_name.items()}
 

src/__init__.py

@@ -13,7 +13,7 @@
 from .Meta import world_description, world_webworld, enable_region_diagram
 from .Locations import location_id_to_name, location_name_to_id, location_name_to_location, location_name_groups, victory_names
 from .Items import item_id_to_name, item_name_to_id, item_name_to_item, item_name_groups
-from .DataValidation import runGenerationDataValidation
+from .DataValidation import runGenerationDataValidation, runPreFillDataValidation
 
 from .Regions import create_regions
 from .Items import ManualItem
@@ -298,6 +298,10 @@ def generate_basic(self):
             from Utils import visualize_regions
             visualize_regions(self.multiworld.get_region("Menu", self.player), f"{self.game}_{self.player}.puml")
 
+    def pre_fill(self):
+        # DataValidation after all the hooks are done but before fill
+        runPreFillDataValidation(self, self.multiworld)
+
     def fill_slot_data(self):
         slot_data = before_fill_slot_data({}, self, self.multiworld, self.player)
 
@@ -386,7 +390,7 @@ def client_data(self):
             'player_id': self.player,
             'items': self.item_name_to_item,
             'locations': self.location_name_to_location,
-            # todo: extract connections out of mutliworld.get_regions() instead, in case hooks have modified the regions.
+            # todo: extract connections out of multiworld.get_regions() instead, in case hooks have modified the regions.
             'regions': region_table,
             'categories': category_table
         }