def from_json(cls, name: str, value: dict, game: RandovaniaGame, item_categories: Dict[str, ItemCategory]) -> "Ammo": return cls( game=game, name=name, model_name=value["model_name"], items=frozen_lib.wrap(value["items"]), broad_category=item_categories[value["broad_category"]], unlocked_by=value.get("unlocked_by"), temporary=value.get("temporary"), extra=frozen_lib.wrap(value.get("extra", {})) )
def decode_data_with_world_reader( data: Dict) -> Tuple[WorldReader, GameDescription]: data = game_migration.migrate_to_current(copy.deepcopy(data)) game = RandovaniaGame(data["game"]) resource_database = read_resource_database(game, data["resource_database"]) dock_weakness_database = read_dock_weakness_database( data["dock_weakness_database"], resource_database) layers = frozen_lib.wrap(data["layers"]) world_reader = WorldReader(resource_database, dock_weakness_database) world_list = world_reader.read_world_list(data["worlds"]) victory_condition = read_requirement(data["victory_condition"], resource_database) starting_location = AreaIdentifier.from_json(data["starting_location"]) initial_states = read_initial_states(data["initial_states"], resource_database) minimal_logic = read_minimal_logic_db(data["minimal_logic"]) return world_reader, GameDescription( game=game, resource_database=resource_database, layers=layers, dock_weakness_database=dock_weakness_database, world_list=world_list, victory_condition=victory_condition, starting_location=starting_location, initial_states=initial_states, minimal_logic=minimal_logic, )
def read_world(self, data: Dict) -> World: self.current_world_name = data["name"] return World( data["name"], self.read_area_list(data["areas"]), frozen_lib.wrap(data["extra"]), )
def encode_extra(qt_value): try: decoded = json.loads(qt_value) if isinstance(decoded, dict): return True, frozen_lib.wrap(decoded) except json.JSONDecodeError: return False, None
def read_dock_weakness(name: str, item: dict, resource_database: ResourceDatabase) -> DockWeakness: return DockWeakness( name, frozen_lib.wrap(item["extra"]), read_requirement(item["requirement"], resource_database), read_dock_lock(item["lock"], resource_database), )
def __post_init__(self): if not self.layers: raise ValueError("Expected at least one layer") if not isinstance(self.extra, frozendict): if not isinstance(self.extra, dict): raise ValueError(f"Expected dict for extra, got {type(self.extra)}") object.__setattr__(self, "extra", frozen_lib.wrap(self.extra))
def from_json(cls, name: str, value: dict) -> "ItemCategory": return cls( name=name, long_name=value["long_name"], hint_details=frozen_lib.wrap(value["hint_details"]), is_major=value["is_major"], is_key=value["is_key"] if "is_key" in value else False )
def from_json(cls, name: str, value: dict, game: RandovaniaGame, item_categories: Dict[str, ItemCategory]) -> "MajorItem": return cls(game=game, name=name, item_category=item_categories[value["item_category"]], broad_category=item_categories[value["broad_category"]], model_name=value["model_name"], progression=frozen_lib.wrap(value["progression"]), default_shuffled_count=value["default_shuffled_count"], default_starting_count=value["default_starting_count"], ammo_index=frozen_lib.wrap(value.get("ammo", [])), unlocks_ammo=value.get("unlocks_ammo", False), hide_from_gui=value.get("hide_from_gui", False), must_be_starting=value.get("must_be_starting", False), original_index=PickupIndex(value["original_index"]) if "original_index" in value else None, probability_offset=value["probability_offset"], probability_multiplier=value["probability_multiplier"], warning=value.get("warning"), extra=frozen_lib.wrap(value.get("extra", {})))
def read_trick_resource_info(name: str, data: Dict) -> TrickResourceInfo: return TrickResourceInfo(data["long_name"], name, data["description"], frozen_lib.wrap(data["extra"]))
def read_item_resource_info(name: str, data: Dict) -> ItemResourceInfo: return ItemResourceInfo(data["long_name"], name, data["max_capacity"], frozen_lib.wrap(data["extra"]))
def read_resource_info(name: str, data: Dict, resource_type: ResourceType) -> SimpleResourceInfo: return SimpleResourceInfo(data["long_name"], name, resource_type, frozen_lib.wrap(data["extra"]))
def read_node(self, name: str, data: Dict) -> Node: try: location = None if data["coordinates"] is not None: location = location_from_json(data["coordinates"]) generic_args = { "identifier": NodeIdentifier.create(self.current_world_name, self.current_area_name, name), "heal": data["heal"], "location": location, "description": data["description"], "layers": tuple(data["layers"]), "extra": frozen_lib.wrap(data["extra"]), } node_type: int = data["node_type"] if node_type == "generic": return GenericNode(**generic_args) elif node_type == "dock": return DockNode( **generic_args, dock_type=self.dock_weakness_database.find_type( data["dock_type"]), default_connection=NodeIdentifier.from_json( data["default_connection"]), default_dock_weakness=self.dock_weakness_database. get_by_weakness( data["dock_type"], data["default_dock_weakness"], ), override_default_open_requirement=read_optional_requirement( data["override_default_open_requirement"], self.resource_database), override_default_lock_requirement=read_optional_requirement( data["override_default_lock_requirement"], self.resource_database), ) elif node_type == "pickup": return PickupNode( **generic_args, pickup_index=PickupIndex(data["pickup_index"]), major_location=data["major_location"], ) elif node_type == "teleporter": return TeleporterNode( **generic_args, default_connection=AreaIdentifier.from_json( data["destination"]), keep_name_when_vanilla=data["keep_name_when_vanilla"], editable=data["editable"], ) elif node_type == "event": return EventNode( **generic_args, event=self.resource_database.get_by_type_and_index( ResourceType.EVENT, data["event_name"])) elif node_type == "configurable_node": return ConfigurableNode(**generic_args, ) elif node_type == "logbook": lore_type = LoreType(data["lore_type"]) if lore_type == LoreType.REQUIRES_ITEM: required_translator = self.resource_database.get_item( data["extra"]["translator"]) else: required_translator = None if lore_type in { LoreType.SPECIFIC_PICKUP, LoreType.SKY_TEMPLE_KEY_HINT }: hint_index = data["extra"]["hint_index"] else: hint_index = None return LogbookNode( **generic_args, string_asset_id=data["string_asset_id"], scan_visor=self._get_scan_visor(), lore_type=lore_type, required_translator=required_translator, hint_index=hint_index, ) elif node_type == "player_ship": return PlayerShipNode( **generic_args, is_unlocked=read_requirement(data["is_unlocked"], self.resource_database), item_to_summon=self._get_command_visor(), ) else: raise Exception(f"Unknown type: {node_type}") except Exception as e: raise Exception(f"In node {name}, got error: {e}")
def read_dock_type(name: str, data: dict) -> DockType: return DockType( short_name=name, long_name=data["name"], extra=frozen_lib.wrap(data["extra"]), )
def _create_item(self, short_name) -> TrickResourceInfo: return TrickResourceInfo(short_name, short_name, "", frozen_lib.wrap({}))
def _create_item(self, short_name) -> ItemResourceInfo: return ItemResourceInfo(short_name, short_name, 1, frozen_lib.wrap({}))
def _create_item(self, short_name) -> ResourceInfo: return SimpleResourceInfo(short_name, short_name, self.resource_type, frozen_lib.wrap({}))