Merge remote-tracking branch 'origin/main' into client-improvements

# Conflicts:
#	src/__init__.py

Author: silasary

docs/making/game.md

@@ -3,7 +3,7 @@
 Game.json contains the most fundamental details about your Manual Game, the details about the game itself.
 
 At its most basic, it needs the name of the game, and name of the creator (you).
-It also contains the name of the auto-generated filler item, and details about Starting Inventory (see below for more details)
+It also contains the name of the auto-generated filler item, and details about [Starting Inventory](#starting-inventory) and whether [Deathlink](#death-link) is enabled.
 
 ```json
 {
@@ -84,5 +84,19 @@ This works like the first one, except with categories instead of items. There's
 ```
 Lastly, this gives you three completely random items.
 
+## Death Link
+
+Enabling Deathlink is very simple.  Just add `"death_link": true` to your game.json, and you'll get a yaml setting and fancy button in the client.
+
+```json
+{
+    "game": "Snolf",
+    "creator": "YourNameHere",
+    "filler_item_name": "Gold Rings",
+    "death_link": true
+}
+```
+
+If you turn this on, make sure you have a clear (and documented) understanding of what a death is, when players should send one, and what it means to receive it.
 
 Next: Add your [items](/docs/making/items.md)

schemas/Manual.game.schema.json

@@ -28,6 +28,10 @@
                 "$ref": "#/definitions/Sitems"
             }
         },
+        "death_link": {
+            "description": "(Optional) Does your game support Deathlink?",
+            "type": "boolean"
+        },
         "_comment": {"$ref": "#/definitions/comment"}
     },
     "required":["game", "filler_item_name"],

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:
@@ -270,7 +376,10 @@ def checkStartingItemsForBadSyntax():
     @staticmethod
     def checkPlacedItemsAndCategoriesForBadSyntax():
         for location in DataValidation.location_table:
-            if not (place_item := location.get("place_item", False)) and not (place_item_category := location.get("place_item_category", False)):
+            place_item = location.get("place_item", False)
+            place_item_category = location.get("place_item_category", False)
+
+            if not place_item and not place_item_category:
                 continue
 
             if place_item and type(place_item) is not list:
@@ -338,7 +447,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 +476,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/ManualClient.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
+import time
 from typing import Any
+import typing
 from worlds import AutoWorldRegister, network_data_package
 import json
 
@@ -45,6 +47,10 @@ class ManualContext(SuperContext):
     tracker_reachable_locations = []
     tracker_reachable_events = []
 
+    set_deathlink = False
+    last_death_link = 0
+    deathlink_out = False
+
     def __init__(self, server_address, password, game, player_name) -> None:
         super(ManualContext, self).__init__(server_address, password)
 
@@ -55,7 +61,6 @@ def __init__(self, server_address, password, game, player_name) -> None:
 
         self.send_index: int = 0
         self.syncing = False
-        self.awaiting_bridge = False
         self.game = game
         self.username = player_name
 
@@ -146,6 +151,10 @@ def on_package(self, cmd: str, args: dict):
                 goal = args["slot_data"].get("goal")
                 if goal and goal < len(self.victory_names):
                     self.goal_location = self.get_location_by_name(self.victory_names[goal])
+                if args['slot_data'].get('death_link'):
+                    self.ui.enable_death_link()
+                    self.set_deathlink = True
+                    self.last_death_link = 0
                 logger.info(f"Slot data: {args['slot_data']}")
 
             self.ui.build_tracker_and_locations_table()
@@ -155,6 +164,12 @@ def on_package(self, cmd: str, args: dict):
         elif cmd in {"RoomUpdate"}:
             self.ui.update_tracker_and_locations_table(update_highlights=False)
 
+    def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
+        super().on_deathlink(data)
+        self.ui.death_link_button.text = f"Death Link: {data['source']}"
+        self.ui.death_link_button.background_color = [1, 0, 0, 1]
+        
+        
     def on_tracker_updated(self, reachable_locations: list[str]):
         self.tracker_reachable_locations = reachable_locations
         self.ui.update_tracker_and_locations_table(update_highlights=True)
@@ -267,6 +282,23 @@ def set_active_location_accordion(self, instance):
 
                     index += 1
 
+            def enable_death_link(self):
+                if not hasattr(self, "death_link_button"):
+                    self.death_link_button = Button(text="Death Link: Primed",
+                                                size_hint_x=None, width=150)
+                    self.connect_layout.add_widget(self.death_link_button)
+                    self.death_link_button.bind(on_press=self.send_death_link)
+
+            def send_death_link(self, *args):
+                if self.ctx.last_death_link:
+                    self.ctx.last_death_link = 0
+                    self.death_link_button.text = "Death Link: Primed"
+                    self.death_link_button.background_color = [1, 1, 1, 1]
+                else:
+                    self.ctx.deathlink_out = True
+                    self.death_link_button.text = "Death Link: Sent"
+                    self.death_link_button.background_color = [0, 1, 0, 1]
+
             def update_hints(self):
                 super().update_hints()
                 rebuild = False
@@ -600,6 +632,15 @@ async def game_watcher_manual(ctx: ManualContext):
                 sync_msg.append({"cmd": "LocationChecks", "locations": list(ctx.locations_checked)})
             await ctx.send_msgs(sync_msg)
             ctx.syncing = False
+
+        if ctx.set_deathlink:
+            ctx.set_deathlink = False
+            await ctx.update_death_link(True)
+
+        if ctx.deathlink_out:
+            ctx.deathlink_out = False
+            await ctx.send_death()
+
         sending = []
         victory = ("__Victory__" in ctx.items_received)
         ctx.locations_checked = sending

src/Options.py

@@ -1,7 +1,7 @@
-from Options import FreeText, NumericOption, Toggle, DefaultOnToggle, Choice, TextChoice, Range, NamedRange, PerGameCommonOptions
+from Options import FreeText, NumericOption, Toggle, DefaultOnToggle, Choice, TextChoice, Range, NamedRange, PerGameCommonOptions, DeathLink
 from dataclasses import make_dataclass
 from .hooks.Options import before_options_defined, after_options_defined
-from .Data import category_table
+from .Data import category_table, game_table
 from .Locations import victory_names
 from .Items import item_table
 
@@ -20,6 +20,9 @@ class FillerTrapPercent(Range):
 if any(item.get('trap') for item in item_table):
     manual_options["filler_traps"] = FillerTrapPercent
 
+if game_table.get("death_link"):
+    manual_options["death_link"] = DeathLink
+
 for category in category_table:
     for option_name in category_table[category].get("yaml_option", []):
         if option_name[0] == "!":