def test_connections_from_dock_blast_shield(empty_patches):
# Setup
trivial = Requirement.trivial()
req_1 = ResourceRequirement.simple(
SimpleResourceInfo(0, "Ev1", "Ev1", ResourceType.EVENT))
req_2 = ResourceRequirement.simple(
SimpleResourceInfo(1, "Ev2", "Ev2", ResourceType.EVENT))
dock_type = DockType("Type", "Type", frozendict())
weak_1 = DockWeakness(0, "Weak 1", frozendict(), req_1, None)
weak_2 = DockWeakness(1, "Weak 2", frozendict(), trivial,
DockLock(DockLockType.FRONT_BLAST_BACK_BLAST, req_2))
node_1_identifier = NodeIdentifier.create("W", "Area 1", "Node 1")
node_2_identifier = NodeIdentifier.create("W", "Area 2", "Node 2")
node_1 = DockNode(node_1_identifier, 0, False, None, "", ("default", ), {},
dock_type, node_2_identifier, weak_1, None, None)
node_1_lock = DockLockNode.create_from_dock(node_1, 1)
node_2 = DockNode(node_2_identifier, 2, False, None, "", ("default", ), {},
dock_type, node_1_identifier, weak_2, None, None)
node_2_lock = DockLockNode.create_from_dock(node_2, 3)
area_1 = Area("Area 1", None, True, [node_1, node_1_lock], {}, {})
area_2 = Area("Area 2", None, True, [node_2, node_2_lock], {}, {})
world = World("W", [area_1, area_2], {})
world_list = WorldList([world])
world_list.ensure_has_node_cache()
game_mock = MagicMock()
game_mock.world_list = world_list
patches = dataclasses.replace(empty_patches, game=game_mock)
context = NodeContext(
patches=patches,
current_resources=ResourceCollection(),
database=patches.game.resource_database,
node_provider=world_list,
)
# Run
result_1 = list(node_1.connections_from(context))
result_2 = list(node_2.connections_from(context))
# Assert
simple = ResourceRequirement.simple
assert result_1 == [
(node_2,
RequirementAnd(
[req_1,
simple(NodeResourceInfo.from_node(node_2, context))])),
(node_1_lock, RequirementAnd([trivial, req_2])),
]
assert result_2 == [
(node_1, simple(NodeResourceInfo.from_node(node_2, context))),
(node_2_lock, req_2),
]
def _requirement_from_back(context: NodeContext, target_node: Node) -> typing.Optional[ResourceRequirement]:
if isinstance(target_node, DockNode):
weak = context.patches.get_dock_weakness_for(target_node)
if weak.lock is not None:
return ResourceRequirement.simple(NodeResourceInfo.from_node(target_node, context))
return None
def _open_dock_connection(self, context: NodeContext, target_node: Node,
) -> tuple[Node, Requirement]:
forward_weakness = self.get_front_weakness(context)
reqs: list[Requirement] = [self._get_open_requirement(context, forward_weakness)]
# This dock has a lock, so require it
if forward_weakness.lock is not None:
reqs.append(ResourceRequirement.simple(NodeResourceInfo.from_node(self, context)))
# The other dock has a lock, so require it
if (other_lock_req := _requirement_from_back(context, target_node)) is not None:
reqs.append(other_lock_req)
def resource_gain_on_collect(self, context: NodeContext) -> ResourceGain:
dock = self.dock
dock_resource = self.resource(context)
target_resource = NodeResourceInfo.from_node(
dock.get_target_identifier(context), context)
front_weak = dock.get_front_weakness(context)
if not context.has_resource(
dock_resource) and front_weak.lock is not None:
yield dock_resource, 1
if not context.has_resource(
target_resource) and front_weak.can_unlock_from_back(
dock.get_back_weakness(context)):
yield target_resource, 1
def can_collect(self, context: NodeContext) -> bool:
dock = self.dock
front_weak = dock.get_front_weakness(context)
if not context.has_resource(self.resource(context)):
if front_weak.lock is not None:
return True
target = dock.get_target_identifier(context)
if not context.has_resource(NodeResourceInfo.from_node(
target, context)):
if front_weak.can_unlock_from_back(
dock.get_back_weakness(context)):
return True
return False
def test_sort_resource_requirement(blank_game_description):
db = blank_game_description.resource_database
node = blank_game_description.world_list.all_nodes[0]
assert node is not None
resources = [
NodeResourceInfo.from_node(
node, NodeContext(None, None, db,
blank_game_description.world_list)),
SimpleResourceInfo(1, "Resource", "Resource", ResourceType.MISC),
TrickResourceInfo(2, "Trick", "Trick", "Long Description"),
ItemResourceInfo(3, "Item", "Item", 1),
]
# Assert resources has an entry for every type of ResourceInfo
assert {type(it) for it in resources} == set(ResourceInfo.__args__)
assert len(resources) == len(ResourceInfo.__args__)
requirements = [ResourceRequirement.simple(it) for it in resources]
result = sorted(requirements)
assert result == list(reversed(requirements))
def resource(self, context: NodeContext) -> NodeResourceInfo:
return NodeResourceInfo.from_node(self, context)