Core: Add "CounterOption", use it for generic "StartInventory" and Witness "TrapWeights"

Options.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import abc
+import collections
 import functools
 import logging
 import math
@@ -854,13 +855,51 @@ def __iter__(self) -> typing.Iterator[str]:
     def __len__(self) -> int:
         return self.value.__len__()
 
+    # __getitem__ fallback fails for Counters, so we define this explicitly
+    def __contains__(self, item):
+        return item in self.value
+
+
+class CounterOption(OptionDict):
+    min: typing.Optional[int] = None
+    max: typing.Optional[int] = None
+
+    def __init__(self, value: typing.Dict[str, int]):
+        super(CounterOption, self).__init__(collections.Counter(value))
+
+    def verify(self, world: typing.Type[World], player_name: str, plando_options: PlandoOptions) -> None:
+        super(CounterOption, self).verify(world, player_name, plando_options)
 
-class ItemDict(OptionDict):
+        range_errors = []
+
+        if self.max is not None:
+            range_errors += [
+                f"\"{key}: {value}\" is higher than maximum allowed value {self.max}."
+                for key, value in self.value.items() if value > self.max
+            ]
+
+        if self.min is not None:
+            range_errors += [
+                f"\"{key}: {value}\" is lower than minimum allowed value {self.min}."
+                for key, value in self.value.items() if value < self.min
+            ]
+
+        if len(range_errors) == 1:
+            raise OptionError(range_errors[0][:-1] + f" for option {getattr(self, 'display_name', self)}.")
+        elif range_errors:
+            range_errors = [f"For option {getattr(self, 'display_name', self)}:"] + range_errors
+            raise OptionError("\n".join(range_errors))
+
+
+class ItemDict(CounterOption):
     verify_item_name = True
 
+    min = 0
+
     def __init__(self, value: typing.Dict[str, int]):
-        if any(item_count < 1 for item_count in value.values()):
-            raise Exception("Cannot have non-positive item counts.")
+        # Backwards compatibility: Cull 0s to make "in" checks behave the same as when this wasn't a CounterOption
+        value = {item_name: amount for item_name, amount in value.items() if amount != 0}
+
         super(ItemDict, self).__init__(value)
 
 

Utils.py

@@ -419,6 +419,9 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
     def find_class(self, module: str, name: str) -> type:
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
+        # used by CounterOption
+        if module == "collections" and name == "Counter":
+            return collections.Counter
         # used by MultiServer -> savegame/multidata
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
             return getattr(self.net_utils_module, name)

WebHostLib/options.py

@@ -108,7 +108,7 @@ def option_presets(game: str) -> Response:
                     f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
 
                 presets[preset_name][preset_option_name] = option.value
-            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.ItemDict)):
+            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.CounterOption)):
                 presets[preset_name][preset_option_name] = option.value
             elif isinstance(preset_option, str):
                 # Ensure the option value is valid for Choice and Toggle options
@@ -216,7 +216,7 @@ def generate_yaml(game: str):
 
         for key, val in options.copy().items():
             key_parts = key.rsplit("||", 2)
-            # Detect and build ItemDict options from their name pattern
+            # Detect and build CounterOption options from their name pattern
             if key_parts[-1] == "qty":
                 if key_parts[0] not in options:
                     options[key_parts[0]] = {}

WebHostLib/templates/playerOptions/macros.html

@@ -111,7 +111,7 @@
     </div>
 {% endmacro %}
 
-{% macro ItemDict(option_name, option) %}
+{% macro CounterOption(option_name, option) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
         {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}

WebHostLib/templates/playerOptions/playerOptions.html

@@ -93,8 +93,8 @@ <h1>Player Options</h1>
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
-                                            {{ inputs.ItemDict(option_name, option) }}
+                                        {% elif issubclass(option, Options.CounterOption) and option.valid_keys %}
+                                            {{ inputs.CounterOption(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}
@@ -133,8 +133,8 @@ <h1>Player Options</h1>
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
-                                            {{ inputs.ItemDict(option_name, option) }}
+                                        {% elif issubclass(option, Options.CounterOption) and option.valid_keys %}
+                                            {{ inputs.CounterOption(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}

WebHostLib/templates/weightedOptions/macros.html

@@ -113,7 +113,7 @@
     {{ TextChoice(option_name, option) }}
 {% endmacro %}
 
-{% macro ItemDict(option_name, option, world) %}
+{% macro CounterOption(option_name, option, world) %}
     <div class="dict-container">
         {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
             <div class="dict-entry">

WebHostLib/templates/weightedOptions/weightedOptions.html

@@ -83,8 +83,8 @@ <h4>{{ option.display_name|default(option_name) }}</h4>
                                 {% elif issubclass(option, Options.FreeText) %}
                                     {{ inputs.FreeText(option_name, option) }}
 
-                                {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
-                                    {{ inputs.ItemDict(option_name, option, world) }}
+                                {% elif issubclass(option, Options.CounterOption) and option.valid_keys %}
+                                    {{ inputs.CounterOption(option_name, option, world) }}
 
                                 {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                     {{ inputs.OptionList(option_name, option) }}

worlds/witness/options.py

@@ -1,8 +1,6 @@
 from dataclasses import dataclass
 
-from schema import And, Schema
-
-from Options import Choice, DefaultOnToggle, OptionDict, OptionGroup, PerGameCommonOptions, Range, Toggle, Visibility
+from Options import Choice, CounterOption, DefaultOnToggle, OptionGroup, PerGameCommonOptions, Range, Toggle, Visibility
 
 from .data import static_logic as static_witness_logic
 from .data.item_definition_classes import ItemCategory, WeightedItemDefinition
@@ -234,23 +232,25 @@ class TrapPercentage(Range):
     default = 20
 
 
-class TrapWeights(OptionDict):
+_default_trap_weights = {
+    trap_name: item_definition.weight
+    for trap_name, item_definition in static_witness_logic.ALL_ITEMS.items()
+    if isinstance(item_definition, WeightedItemDefinition) and item_definition.category is ItemCategory.TRAP
+}
+
+
+class TrapWeights(CounterOption):
     """
     Specify the weights determining how many copies of each trap item will be in your itempool.
-    If you don't want a specific type of trap, you can set the weight for it to 0 (Do not delete the entry outright!).
+    If you don't want a specific type of trap, you can set the weight for it to 0.
     If you set all trap weights to 0, you will get no traps, bypassing the "Trap Percentage" option.
     """
     display_name = "Trap Weights"
-    schema = Schema({
-        trap_name: And(int, lambda n: n >= 0)
-        for trap_name, item_definition in static_witness_logic.ALL_ITEMS.items()
-        if isinstance(item_definition, WeightedItemDefinition) and item_definition.category is ItemCategory.TRAP
-    })
-    default = {
-        trap_name: item_definition.weight
-        for trap_name, item_definition in static_witness_logic.ALL_ITEMS.items()
-        if isinstance(item_definition, WeightedItemDefinition) and item_definition.category is ItemCategory.TRAP
-    }
+    valid_keys = _default_trap_weights.keys()
+
+    min = 0
+
+    default = _default_trap_weights
 
 
 class PuzzleSkipAmount(Range):