def test_connections_from_dock_blast_shield(empty_patches):
# Setup
trivial = Requirement.trivial()
req_1 = ResourceRequirement(
SimpleResourceInfo("Ev1", "Ev1", ResourceType.EVENT), 1, False)
req_2 = ResourceRequirement(
SimpleResourceInfo("Ev2", "Ev2", ResourceType.EVENT), 1, False)
dock_type = DockType("Type", "Type", frozendict())
weak_1 = DockWeakness("Weak 1", frozendict(), req_1, None)
weak_2 = DockWeakness("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, False, None, "", ("default", ), {},
dock_type, node_2_identifier, weak_1, None, None)
node_1_lock = DockLockNode.create_from_dock(node_1)
node_2 = DockNode(node_2_identifier, False, None, "", ("default", ), {},
dock_type, node_1_identifier, weak_2, None, None)
node_2_lock = DockLockNode.create_from_dock(node_2)
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])
context = NodeContext(
patches=empty_patches,
current_resources={},
database=None,
node_provider=world_list,
)
# Run
result_1 = list(node_1.connections_from(context))
result_2 = list(node_2.connections_from(context))
# Assert
assert result_1 == [
(node_2,
RequirementAnd([req_1,
ResourceRequirement.simple(node_2_identifier)])),
(node_1_lock, RequirementAnd([trivial, req_2])),
]
assert result_2 == [
(node_1, ResourceRequirement.simple(node_2_identifier)),
(node_2_lock, req_2),
]
def test_node_identifier_as_requirement():
nic = NodeIdentifier.create
req = ResourceRequirement.simple(nic("W", "A", "N"))
db = typing.cast(ResourceDatabase, None)
assert not req.satisfied({}, 0, db)
assert req.satisfied({nic("W", "A", "N"): 1}, 0, db)
def _requirement_from_back(
context: NodeContext,
identifier: NodeIdentifier) -> typing.Optional[ResourceRequirement]:
target_node = context.node_provider.node_by_identifier(identifier)
if isinstance(target_node, DockNode):
weak = context.patches.dock_weakness.get(
identifier, target_node.default_dock_weakness)
if weak.lock is not None:
return ResourceRequirement.simple(identifier)
return None
def test_sort_resource_requirement():
resources = [
NodeIdentifier.create("World", "Area", "Node"),
PickupIndex(10),
_make_resource("Resource"),
TrickResourceInfo("Trick", "Trick", "Long Description"),
ItemResourceInfo("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 _open_dock_connection(
self,
context: NodeContext,
target_identifier: NodeIdentifier,
) -> tuple[Node, Requirement]:
forward_weakness = self.get_front_weakness(context)
reqs: list[Requirement] = [
self._get_open_requirement(forward_weakness)
]
# This dock has a lock, so require it
if forward_weakness.lock is not None:
reqs.append(
ResourceRequirement.simple(
context.node_provider.identifier_for_node(self)))
# The other dock has a lock, so require it
if (other_lock_req :=
_requirement_from_back(context,
target_identifier)) is not None:
reqs.append(other_lock_req)