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({}))
