core: move option results to the World class instead of MultiWorld

BaseClasses.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import copy
+import itertools
+from argparse import Namespace
 from enum import unique, IntEnum, IntFlag
 import logging
 import json
@@ -201,18 +203,16 @@ def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optio
                            range(1, self.players + 1)}
 
     def set_options(self, args):
-        for option_key in Options.common_options:
-            setattr(self, option_key, getattr(args, option_key, {}))
-        for option_key in Options.per_game_common_options:
-            setattr(self, option_key, getattr(args, option_key, {}))
-
         for player in self.player_ids:
             self.custom_data[player] = {}
             world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
-            for option_key in world_type.option_definitions:
-                setattr(self, option_key, getattr(args, option_key, {}))
-
             self.worlds[player] = world_type(self, player)
+            for option_key in itertools.chain(Options.common_options, Options.per_game_common_options,
+                                              world_type.option_definitions):
+                option_values = getattr(args, option_key, {})
+                setattr(self, option_key, option_values)
+                if player in option_values:
+                    self.worlds[player].options[option_key] = option_values[player]
 
     def set_item_links(self):
         item_links = {}
@@ -267,12 +267,13 @@ def set_item_links(self):
             group["non_local_items"] = item_link["non_local_items"]
 
     # intended for unittests
-    def set_default_common_options(self):
-        for option_key, option in Options.common_options.items():
-            setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
-        for option_key, option in Options.per_game_common_options.items():
-            setattr(self, option_key, {player_id: option(option.default) for player_id in self.player_ids})
+    @property
+    def default_common_options(self) -> Namespace:
         self.state = CollectionState(self)
+        args = Namespace()
+        for option_key, option in itertools.chain(Options.common_options.items(), Options.per_game_common_options.items()):
+            setattr(args, option_key, {player_id: option.from_any(option.default) for player_id in self.player_ids})
+        return args
 
     def secure(self):
         self.random = secrets.SystemRandom()

Fill.py

@@ -5,6 +5,7 @@
 from collections import Counter, deque
 
 from BaseClasses import CollectionState, Location, LocationProgressType, MultiWorld, Item, ItemClassification
+from Options import Accessibility
 
 from worlds.AutoWorld import call_all
 from worlds.generic.Rules import add_item_rule
@@ -54,7 +55,7 @@ def fill_restrictive(world: MultiWorld, base_state: CollectionState, locations:
             spot_to_fill: typing.Optional[Location] = None
 
             # if minimal accessibility, only check whether location is reachable if game not beatable
-            if world.accessibility[item_to_place.player] == 'minimal':
+            if world.worlds[item_to_place.player].options["accessibility"] == Accessibility.option_minimal:
                 perform_access_check = not world.has_beaten_game(maximum_exploration_state,
                                                                  item_to_place.player) \
                     if single_player_placement else not has_beaten_game

docs/world api.md

@@ -85,7 +85,7 @@ inside a World object.
 ### Player Options
 
 Players provide customized settings for their World in the form of yamls.
-Those are accessible through `self.world.<option_name>[self.player]`. A dict
+Those are accessible through `self.world.options["<option_name>"]`. A dict
 of valid options has to be provided in `self.option_definitions`. Options are automatically
 added to the `World` object for easy access.
 
@@ -210,7 +210,7 @@ AP will only import the `__init__.py`. Depending on code size it makes sense to
 use multiple files and use relative imports to access them.
 
 e.g. `from .Options import mygame_options` from your `__init__.py` will load
-`world/[world_name]/Options.py` and make its `mygame_options` accesible.
+`world/[world_name]/Options.py` and make its `mygame_options` accessible.
 
 When imported names pile up it may be easier to use `from . import Options`
 and access the variable as `Options.mygame_options`.
@@ -262,7 +262,8 @@ to describe it and a `display_name` property for display on the website and in
 spoiler logs.
 
 The actual name as used in the yaml is defined in a `dict[str, Option]`, that is
-assigned to the world under `self.option_definitions`.
+assigned to the world under `self.option_definitions`. By convention, the string
+that defines your option should be in `snake_case`.
 
 Common option types are `Toggle`, `DefaultOnToggle`, `Choice`, `Range`.
 For more see `Options.py` in AP's base directory.
@@ -455,7 +456,7 @@ In addition, the following methods can be implemented and attributes can be set
 ```python
 def generate_early(self) -> None:
     # read player settings to world instance
-    self.final_boss_hp = self.world.final_boss_hp[self.player].value
+    self.final_boss_hp = self.world.options["final_boss_hp"].value
 ```
 
 #### create_item

test/dungeons/TestDungeon.py

@@ -15,11 +15,10 @@
 class TestDungeon(unittest.TestCase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.starting_regions = []  # Where to start exploring
         self.remove_exits = []      # Block dungeon exits
         self.world.difficulty_requirements[1] = difficulties['normal']

test/general/TestFill.py

@@ -1,5 +1,9 @@
+import itertools
 from typing import List, Iterable
 import unittest
+
+import Options
+from Options import Accessibility
 from worlds.AutoWorld import World
 from Fill import FillError, balance_multiworld_progression, fill_restrictive, distribute_items_restrictive
 from BaseClasses import Entrance, LocationProgressType, MultiWorld, Region, RegionType, Item, Location, \
@@ -10,6 +14,7 @@
 def generate_multi_world(players: int = 1) -> MultiWorld:
     multi_world = MultiWorld(players)
     multi_world.player_name = {}
+    args = multi_world.default_common_options
     for i in range(players):
         player_id = i+1
         world = World(multi_world, player_id)
@@ -20,8 +25,12 @@ def generate_multi_world(players: int = 1) -> MultiWorld:
                         "Menu Region Hint", player_id, multi_world)
         multi_world.regions.append(region)
 
+        for option_key in itertools.chain(Options.common_options, Options.per_game_common_options):
+            option_value = getattr(args, option_key, {})
+            setattr(multi_world, option_key, option_value)
+            multi_world.worlds[player_id].options[option_key] = option_value[player_id]
+
     multi_world.set_seed(0)
-    multi_world.set_default_common_options()
 
     return multi_world
 
@@ -187,7 +196,7 @@ def test_minimal_fill(self):
         items = player1.prog_items
         locations = player1.locations
 
-        multi_world.accessibility[player1.id].value = multi_world.accessibility[player1.id].option_minimal
+        multi_world.worlds[player1.id].options["accessibility"] = Accessibility.from_any(Accessibility.option_minimal)
         multi_world.completion_condition[player1.id] = lambda state: state.has(
             items[1].name, player1.id)
         set_rule(locations[1], lambda state: state.has(

test/general/__init__.py

@@ -11,11 +11,10 @@ def setup_default_world(world_type) -> MultiWorld:
     world.game[1] = world_type.game
     world.player_name = {1: "Tester"}
     world.set_seed()
-    args = Namespace()
+    args = world.default_common_options
     for name, option in world_type.option_definitions.items():
         setattr(args, name, {1: option.from_any(option.default)})
     world.set_options(args)
-    world.set_default_common_options()
     for step in gen_steps:
         call_all(world, step)
     return world

test/inverted/TestInverted.py

@@ -15,11 +15,10 @@
 class TestInverted(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.difficulty_requirements[1] = difficulties['normal']
         self.world.mode[1] = "inverted"
         create_inverted_regions(self.world, 1)

test/inverted/TestInvertedBombRules.py

@@ -16,11 +16,10 @@ class TestInvertedBombRules(unittest.TestCase):
     def setUp(self):
         self.world = MultiWorld(1)
         self.world.mode[1] = "inverted"
-        args = Namespace
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
             self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.difficulty_requirements[1] = difficulties['normal']
         create_inverted_regions(self.world, 1)
         create_dungeons(self.world, 1)

test/inverted_minor_glitches/TestInvertedMinor.py

@@ -16,11 +16,10 @@
 class TestInvertedMinor(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.mode[1] = "inverted"
         self.world.logic[1] = "minorglitches"
         self.world.difficulty_requirements[1] = difficulties['normal']

test/inverted_owg/TestInvertedOWG.py

@@ -17,11 +17,10 @@
 class TestInvertedOWG(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.logic[1] = "owglitches"
         self.world.mode[1] = "inverted"
         self.world.difficulty_requirements[1] = difficulties['normal']

test/minor_glitches/TestMinor.py

@@ -16,11 +16,10 @@
 class TestMinor(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.logic[1] = "minorglitches"
         self.world.difficulty_requirements[1] = difficulties['normal']
         self.world.worlds[1].er_seed = 0

test/owg/TestVanillaOWG.py

@@ -17,11 +17,10 @@
 class TestVanillaOWG(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.difficulty_requirements[1] = difficulties['normal']
         self.world.logic[1] = "owglitches"
         self.world.worlds[1].er_seed = 0

test/soe/__init__.py

@@ -17,11 +17,10 @@ def setUp(self):
         self.world.game[1] = self.game
         self.world.player_name = {1: "Tester"}
         self.world.set_seed()
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types[self.game].option_definitions.items():
             setattr(args, name, {1: option.from_any(self.options.get(name, option.default))})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         for step in gen_steps:
             call_all(self.world, step)
 

test/vanilla/TestVanilla.py

@@ -15,11 +15,10 @@
 class TestVanilla(TestBase):
     def setUp(self):
         self.world = MultiWorld(1)
-        args = Namespace()
+        args = self.world.default_common_options
         for name, option in AutoWorld.AutoWorldRegister.world_types["A Link to the Past"].option_definitions.items():
             setattr(args, name, {1: option.from_any(option.default)})
         self.world.set_options(args)
-        self.world.set_default_common_options()
         self.world.logic[1] = "noglitches"
         self.world.difficulty_requirements[1] = difficulties['normal']
         self.world.worlds[1].er_seed = 0

worlds/AutoWorld.py

@@ -5,7 +5,7 @@
 import pathlib
 from typing import Dict, FrozenSet, Set, Tuple, List, Optional, TextIO, Any, Callable, Type, Union, TYPE_CHECKING
 
-from Options import AssembleOptions
+from Options import AssembleOptions, Option
 from BaseClasses import CollectionState
 
 if TYPE_CHECKING:
@@ -121,6 +121,7 @@ class World(metaclass=AutoWorldRegister):
     A Game should have its own subclass of World in which it defines the required data structures."""
 
     option_definitions: Dict[str, AssembleOptions] = {}  # link your Options mapping
+    options: Dict[str, Option[Any]]  # automatically populated option names to resulting option object
     game: str  # name the game
     topology_present: bool = False  # indicate if world type has any meaningful layout/pathing
 
@@ -188,6 +189,7 @@ class World(metaclass=AutoWorldRegister):
     def __init__(self, world: "MultiWorld", player: int):
         self.world = world
         self.player = player
+        self.options = {}
 
     # overridable methods that get called by Main.py, sorted by execution order
     # can also be implemented as a classmethod and called "stage_<original_name>",