def test_calculate_dangerous_resources(danger_a, danger_b, expected_result):
set_a: Requirement = MagicMock()
set_b: Requirement = MagicMock()
set_a.as_set.dangerous_resources = danger_a
set_b.as_set.dangerous_resources = danger_b
n1: Node = "n1"
n2: Node = "n2"
area_a = Area("area_a", False, 0, 0, True, [n1, n2], {
n1: {
n2: set_a
},
n2: {}
})
area_b = Area("area_b", True, 0, 0, True, [n1, n2], {
n1: {},
n2: {
n1: set_b
}
})
# Run
result = game_description._calculate_dangerous_resources_in_areas(
[area_a, area_b])
# Assert
assert set(result) == set(expected_result)
def read_area(self, data: Dict) -> Area:
nodes = read_array(data["nodes"], self.read_node)
nodes_by_name = {node.name: node for node in nodes}
connections = {}
for i, origin_data in enumerate(data["nodes"]):
origin = nodes[i]
connections[origin] = {}
for target_name, target_requirement in origin_data[
"connections"].items():
try:
the_set = read_requirement(target_requirement,
self.resource_database)
except MissingResource as e:
raise MissingResource(
f"In area {data['name']}, connection from {origin.name} to {target_name} got error: {e}"
)
if the_set != Requirement.impossible():
connections[origin][nodes_by_name[target_name]] = the_set
area_name = data["name"]
try:
return Area(area_name, data["in_dark_aether"], data["asset_id"],
data["default_node_index"],
data["valid_starting_location"], nodes, connections)
except KeyError as e:
raise KeyError(f"Missing key `{e}` for area `{area_name}`")
def read_area(self, data: Dict) -> Area:
name = data["name"]
nodes = read_array(data["nodes"], self.read_node)
nodes_by_name = {node.name: node for node in nodes}
connections = {}
for i, origin_data in enumerate(data["nodes"]):
origin = nodes[i]
connections[origin] = {}
extra_requirement = None
if is_resource_node(
origin) and self.add_self_as_requirement_to_resources:
extra_requirement = RequirementList.with_single_resource(
origin.resource())
for target_name, target_requirements in origin_data[
"connections"].items():
the_set = read_requirement_set(target_requirements,
self.resource_database)
if extra_requirement is not None:
the_set = the_set.union(RequirementSet([extra_requirement
]))
if the_set != RequirementSet.impossible():
connections[origin][nodes_by_name[target_name]] = the_set
return Area(name, data["asset_id"], data["default_node_index"], nodes,
connections)
def _create_world_list(asset_id: int, pickup_index: PickupIndex):
logbook_node = LogbookNode("Logbook A", True, None, 0, asset_id, None,
None, None, None)
pickup_node = PickupNode("Pickup Node", True, None, 1, pickup_index, True)
world_list = WorldList([
World("World", "Dark World", 5000, [
Area("Area", False, 10000, 0, True, [logbook_node, pickup_node],
{}),
Area("Other Area", False, 20000, 0, True, [
PickupNode(f"Pickup {i}", True, None, 1, PickupIndex(i), True)
for i in range(pickup_index.index)
], {}),
]),
])
return logbook_node, pickup_node, world_list
def test_basic_search_with_translator_gate(has_translator: bool,
echoes_resource_database):
# Setup
scan_visor = echoes_resource_database.get_item(10)
node_a = GenericNode("Node A", True, None, 0)
node_b = GenericNode("Node B", True, None, 1)
node_c = GenericNode("Node C", True, None, 2)
translator_node = TranslatorGateNode("Translator Gate", True, None, 3,
TranslatorGate(1), scan_visor)
world_list = WorldList([
World("Test World", "Test Dark World", 1, [
Area(
"Test Area A", False, 10, 0, True,
[node_a, node_b, node_c, translator_node], {
node_a: {
node_b: Requirement.trivial(),
translator_node: Requirement.trivial(),
},
node_b: {
node_a: Requirement.trivial(),
},
node_c: {
translator_node: Requirement.trivial(),
},
translator_node: {
node_a: Requirement.trivial(),
node_c: Requirement.trivial(),
},
})
])
])
game_specific = EchoesGameSpecific(energy_per_tank=100,
safe_zone_heal_per_second=1,
beam_configurations=(),
dangerous_energy_tank=False)
game = GameDescription(RandovaniaGame.PRIME2,
DockWeaknessDatabase([], [], [], []),
echoes_resource_database, game_specific,
Requirement.impossible(), None, {}, world_list)
patches = game.create_game_patches()
patches = patches.assign_gate_assignment({TranslatorGate(1): scan_visor})
initial_state = State({scan_visor: 1 if has_translator else 0}, (), 99,
node_a, patches, None, echoes_resource_database,
game.world_list)
# Run
reach = reach_with_all_safe_resources(game, initial_state)
# Assert
if has_translator:
assert set(
reach.safe_nodes) == {node_a, node_b, translator_node, node_c}
else:
assert set(reach.safe_nodes) == {node_a, node_b}
def test_basic_search_with_translator_gate(has_translator: bool,
echoes_resource_database):
# Setup
scan_visor = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 10)
node_a = GenericNode("Node A", True, 0)
node_b = GenericNode("Node B", True, 1)
node_c = GenericNode("Node C", True, 2)
translator_node = TranslatorGateNode("Translator Gate", True, 3,
TranslatorGate(1), scan_visor)
world_list = WorldList([
World("Test World", 1, [
Area(
"Test Area A", False, 10, 0,
[node_a, node_b, node_c, translator_node], {
node_a: {
node_b: RequirementSet.trivial(),
translator_node: RequirementSet.trivial(),
},
node_b: {
node_a: RequirementSet.trivial(),
},
node_c: {
translator_node: RequirementSet.trivial(),
},
translator_node: {
node_a: RequirementSet.trivial(),
node_c: RequirementSet.trivial(),
},
})
])
])
game = GameDescription(0, "",
DockWeaknessDatabase([], [], [],
[]), echoes_resource_database,
RequirementSet.impossible(), None, {}, world_list)
patches = GamePatches.with_game(game)
patches = patches.assign_gate_assignment({TranslatorGate(1): scan_visor})
initial_state = State({scan_visor: 1 if has_translator else 0}, (), 99,
node_a, patches, None, echoes_resource_database)
# Run
reach = reach_with_all_safe_resources(game, initial_state)
# Assert
if has_translator:
assert set(
reach.safe_nodes) == {node_a, node_b, translator_node, node_c}
else:
assert set(reach.safe_nodes) == {node_a, node_b}
def _create_world_list(asset_id: int, pickup_index: PickupIndex):
logbook_node = LogbookNode("Logbook A", True, 0, asset_id, None, None,
None, None)
pickup_node = PickupNode("Pickup Node", True, 1, pickup_index, True)
world_list = WorldList([
World("World", 5000, [
Area("Area", False, 10000, 0, [logbook_node, pickup_node], {}),
]),
])
return logbook_node, pickup_node, world_list
def read_area(self, data: Dict) -> Area:
nodes = read_array(data["nodes"], self.read_node)
nodes_by_name = {node.name: node for node in nodes}
connections = {}
for i, origin_data in enumerate(data["nodes"]):
origin = nodes[i]
connections[origin] = {}
for target_name, target_requirements in origin_data["connections"].items():
the_set = read_requirement_set(target_requirements, self.resource_database)
if the_set != RequirementSet.impossible():
connections[origin][nodes_by_name[target_name]] = the_set
return Area(data["name"], data["in_dark_aether"], data["asset_id"], data["default_node_index"],
nodes, connections)