Merge changes from 0.6 dev

Author: CodeTriangle

worlds/crosscode/codegen/context.py

@@ -38,6 +38,10 @@ class Context:
     """
     The number of items in the item database.
     """
+    area_names: dict[str, str]
+    """
+    Dict associating internal area names with their English fancy names.
+    """
 
     def __post_init__(self):
         self.num_items = len(self.item_data)
@@ -63,10 +67,17 @@ def make_context_from_package(package: str) -> Context:
     except FileNotFoundError:
         pass
 
+    database = get_json_object(package, "data/assets/data/database.json")
+
+    area_names = {
+        name: data["name"]["en_US"] for name, data in database["areas"].items()
+    }
+
     return Context(
         master,
         get_json_object(package, "data/assets/data/item-database.json")["items"],
-        get_json_object(package, "data/assets/data/database.json"),
+        database,
         cached_location_ids,
-        cached_item_ids
+        cached_item_ids,
+        area_names
     )

worlds/crosscode/codegen/lists.py

@@ -3,6 +3,7 @@
 """
 
 from collections import defaultdict
+from enum import StrEnum
 import typing
 
 from BaseClasses import ItemClassification
@@ -14,9 +15,18 @@
 
 from ..types.items import ItemData, ProgressiveItemChainSingle, SingleItemData, ItemPoolEntry, ProgressiveItemChain
 from ..types.locations import AccessInfo, LocationData
-from ..types.condition import Condition, RegionCondition, OrCondition, ShopSlotCondition
+from ..types.condition import Condition, NeverCondition, RegionCondition, OrCondition, ShopSlotCondition
 from ..types.shops import ShopData
 
+class LocationCategory(StrEnum):
+    """
+    Enum of check types, used for location categorization and markers.
+    """
+    CHEST = "Chest"
+    CUTSCENE = "Cutscene"
+    ELEMENT = "Element"
+    QUEST = "Quest"
+
 
 class ListInfo:
     """
@@ -120,13 +130,13 @@ def build(self):
         file = self.ctx.rando_data
 
         if "chests" in file:
-            self.__add_location_list(file["chests"])
+            self.__add_location_list(file["chests"], LocationCategory.CHEST)
         if "cutscenes" in file:
-            self.__add_location_list(file["cutscenes"])
+            self.__add_location_list(file["cutscenes"], LocationCategory.CUTSCENE)
         if "elements" in file:
-            self.__add_location_list(file["elements"])
+            self.__add_location_list(file["elements"], LocationCategory.ELEMENT)
         if "quests" in file:
-            self.__add_location_list(file["quests"], True)
+            self.__add_location_list(file["quests"], LocationCategory.QUEST, True)
 
         self.__add_shop_list(self.ctx.rando_data["shops"])
 
@@ -182,7 +192,7 @@ def __get_or_allocate_item_id(self, name: str) -> int:
 
         return item_id
 
-    def __add_location(self, name: str, raw_loc: dict[str, typing.Any], create_event: bool = False):
+    def __add_location(self, name: str, raw_loc: dict[str, typing.Any], category: LocationCategory, create_event: bool = False):
         """
         Add a location to the lists.
         """
@@ -191,6 +201,8 @@ def __add_location(self, name: str, raw_loc: dict[str, typing.Any], create_event
         item_rewards = rewards.get("items", [])
         num_rewards = max(1, len(item_rewards))
 
+        properties = raw_loc.get("properties", {})
+
         found = False
 
         if name in self.reward_amounts:
@@ -202,7 +214,11 @@ def __add_location(self, name: str, raw_loc: dict[str, typing.Any], create_event
                     "Cannot add or overwrite with {num_rewards}."
                 )
 
-        area = raw_loc.get("location", {}).get("area", None)
+        if category == LocationCategory.QUEST:
+            area = dbentry["area"]
+        else:
+            area = raw_loc.get("location", {}).get("area", None)
+        area_name = self.ctx.area_names[area]
 
         location_names: list[str] = []
 
@@ -233,10 +249,14 @@ def __add_location(self, name: str, raw_loc: dict[str, typing.Any], create_event
             self.pool_locations.append(loc)
             if area != None:
                 try:
-                    self.location_groups[self.ctx.database["areas"][area]["name"]["en_US"]].append(loc)
+                    self.location_groups[area_name].append(loc)
+                    self.location_groups[f"{area_name} {category}s"].append(loc)
                 except KeyError:
                     print(f"Cannot add location '{name}' in area '{area}'")
 
+            if properties.get("alwaysQuest", False):
+                self.location_groups["Always Quests"].append(loc)
+
             if locked:
                 self.locked_locations.append(locid)
 
@@ -256,12 +276,12 @@ def __add_location(self, name: str, raw_loc: dict[str, typing.Any], create_event
             )
             self.events_data[event_name] = event
 
-    def __add_location_list(self, loc_list: dict[str, dict[str, typing.Any]], create_events: bool = False):
+    def __add_location_list(self, loc_list: dict[str, dict[str, typing.Any]], category: LocationCategory, create_events: bool = False):
         """
         Add a list of locations to the list.
         """
         for name, raw_loc in loc_list.items():
-            self.__add_location(name, raw_loc, create_events)
+            self.__add_location(name, raw_loc, category, create_events)
 
     def __add_item_data(self, name: str, raw_item: dict[str, typing.Any]) -> tuple[SingleItemData, ItemData]:
         """
@@ -303,6 +323,8 @@ def __add_shop_unlock_item(self, name: str) -> ItemData:
 
     def __add_shop(self, shop_display_name: str, raw_shop: dict[str, typing.Any]):
         shop_name = raw_shop["location"]["shop"]
+        area = raw_shop["location"]["area"]
+        area_name = self.ctx.area_names[area]
         shop_base_name = shop_display_name.split(" +")[0] # this is a hack until there are heirarchical shops
 
         dbentry = self.ctx.database["shops"][shop_name]
@@ -334,14 +356,17 @@ def __add_shop(self, shop_display_name: str, raw_shop: dict[str, typing.Any]):
             slot_location = LocationData(
                 name=slot_location_name,
                 code=locid,
-                area=None,
+                area=area,
                 metadata=metadata,
                 access=AccessInfo(
                     region={ name: shop_display_name for name in access_info.region },
                     cond=[ShopSlotCondition(shop_name, item_id)],
                 ),
             )
 
+            self.location_groups[area_name].append(slot_location)
+            self.location_groups[f"{area_name} Shops"].append(slot_location)
+
             shop_locs[item_id] = slot_location
             self.locations_data[slot_location.name] = slot_location
 
@@ -476,10 +501,19 @@ def __add_progressive_chains(self, raw: dict[str, dict[str, typing.Any]]):
         for name, chain in raw.items():
             self.__add_progressive_chain(name, chain)
 
-    def __add_vars(self, variables: dict[str, dict[str, list[typing.Any]]]):
+    def __add_vars(self, variables: dict[str, str | dict[str, list[typing.Any]]]):
         """
         Add a list of variable conditions to the list..
         """
         for name, values in variables.items():
+            if isinstance(values, str):
+                if values == "boolean":
+                    self.variable_definitions[name] = {
+                        "off": [NeverCondition()],
+                        "on": []
+                    }
+                    continue
+                else:
+                    raise RuntimeError(f"{values} is not a valid variable type shorthand.")
             for value, conds in values.items():
                 self.variable_definitions[name][value] = self.json_parser.parse_condition(conds)

worlds/crosscode/codegen/parse.py

@@ -13,8 +13,8 @@
 from ..types.items import ItemData, ProgressiveChainEntry, ProgressiveItemChain, ProgressiveItemChainSingle, ProgressiveItemChainMulti, ProgressiveItemSubchain, SingleItemData
 from ..types.locations import AccessInfo, Condition
 from ..types.regions import RegionConnection, RegionsData
-from ..types.condition import ChestKeyCondition, ItemCondition, LocationCondition, QuestCondition, RegionCondition, AnyElementCondition, \
-    OrCondition, VariableCondition
+from ..types.condition import ChestKeyCondition, ItemCondition, LocationCondition, NeverCondition, QuestCondition, RegionCondition, AnyElementCondition, \
+    OrCondition, ShopSlotCondition, VariableCondition
 
 class JsonParserError(Exception):
     """
@@ -120,6 +120,20 @@ def parse_condition(self, raw: list[typing.Any]) -> list[Condition]:
                         f"expected 1 argument, not {num_args}"
                     )
 
+            elif cond[0] == "shop_slot":
+                if num_args == 2:
+                    result.append(ShopSlotCondition(cond[1], cond[2]))
+                else:
+                    raise JsonParserError(
+                        raw,
+                        cond,
+                        "shop slot condition",
+                        f"expected 2 arguments, not {num_args}"
+                    )
+
+            elif cond[0] == "never":
+                result.append(NeverCondition())
+
             else:
                 raise JsonParserError(raw, cond, "condition", f"unknown type {cond[0]}")