def test_requirement_as_set_3(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
req = RequirementOr([
Requirement.impossible(),
_req("A"),
])
assert req.as_set(database) == RequirementSet([
RequirementList([_req("A")]),
])
def test_requirement_as_set_1(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
req = RequirementAnd([
_req("A"),
RequirementOr([_req("B"), _req("C")]),
RequirementOr([_req("D"), _req("E")]),
])
assert req.as_set(database) == RequirementSet([
RequirementList([_req("A"), _req("B"), _req("D")]),
RequirementList([_req("A"), _req("B"), _req("E")]),
RequirementList([_req("A"), _req("C"), _req("D")]),
RequirementList([_req("A"), _req("C"), _req("E")]),
])
def patch_requirements(self, resources: ResourceCollection,
database: ResourceDatabase) -> RequirementSet:
from randovania.game_description.requirements.requirement_and import RequirementAnd
from randovania.game_description.requirements.requirement_or import RequirementOr
return RequirementOr(
RequirementAnd(
individual.patch_requirements(resources, 1, database)
for individual in alternative.values())
for alternative in self.alternatives).as_set(database)
def test_simplify_requirement_set_static(blank_game_description):
db = blank_game_description.resource_database
res_a, id_req_a = make_req_a(db)
res_b, id_req_b = make_req_b(db)
fd = ResourceCollection.from_dict
the_set = RequirementOr([
RequirementAnd([id_req_a]),
RequirementAnd([id_req_b]),
])
simple_1 = the_set.patch_requirements(fd(db, {res_a: 0, res_b: 0}), 1, db)
simple_2 = the_set.patch_requirements(fd(db, {res_a: 0, res_b: 1}), 1, db)
simple_3 = the_set.patch_requirements(fd(db, {res_a: 1, res_b: 1}), 1, db)
assert simple_1.as_set(db).alternatives == frozenset()
assert simple_2.as_set(db).alternatives == frozenset([RequirementList([])])
assert simple_3.as_set(db).alternatives == frozenset([RequirementList([])])
def test_requirement_or_str(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
req = RequirementOr([
_req("C"),
_req("A"),
_req("B"),
])
assert str(req) == "(A ≥ 1 or B ≥ 1 or C ≥ 1)"
def test_requirement_template_nested(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
# Setup
use_a = RequirementTemplate("Use A")
use_b = RequirementTemplate("Use B")
database.requirement_template["Use A"] = _req("A")
database.requirement_template["Use B"] = RequirementOr([use_a, _req("B")])
# Run
as_set = use_b.as_set(database)
# Assert
assert as_set == RequirementSet([
RequirementList([_req("A")]),
RequirementList([_req("B")]),
])
assert hash(use_a) != hash(use_b)
def test_build_no_changes(skip_qtbot, echoes_resource_database):
# Setup
def mk_req(name: str):
return ResourceRequirement.with_data(echoes_resource_database,
ResourceType.ITEM, name, 1, False)
requirement = RequirementOr([
RequirementAnd([
mk_req("Dark"),
mk_req("Light"),
]),
mk_req("Power"),
])
# Run
editor = connections_editor.ConnectionsEditor(None,
echoes_resource_database,
requirement)
skip_qtbot.addWidget(editor)
result = editor.final_requirement
# Assert
assert result == requirement
def impossible(cls) -> Requirement:
# empty RequirementOr.satisfied is False
from randovania.game_description.requirements.requirement_or import RequirementOr
return RequirementOr([])
def test_simplified_requirement(database):
def _req(name: str):
id_req = ResourceRequirement.simple(database.get_item(name))
return id_req
test_parameters = [
(
RequirementOr([
RequirementAnd([
_req("A"),
]),
]),
_req("A"),
), (
RequirementAnd([
RequirementOr([
_req("A"),
]),
]),
_req("A"),
),
(
RequirementAnd([
RequirementOr([_req("B"), Requirement.trivial()]),
RequirementAnd([
Requirement.trivial(),
_req("A"),
]),
]),
_req("A"),
),
(
RequirementOr([
_req("A"),
RequirementAnd([_req("B"), _req("C")]),
RequirementAnd([_req("B"), _req("D")]),
]),
RequirementOr([
_req("A"),
RequirementAnd([
_req("B"),
RequirementOr([
_req("C"),
_req("D"),
]),
]),
]),
),
(
RequirementOr([
RequirementAnd([_req("B"), _req("C")]),
RequirementAnd([_req("B"), _req("D")]),
]),
RequirementAnd([
_req("B"),
RequirementOr([
_req("C"),
_req("D"),
]),
]),
), (
RequirementOr([
_req("A"),
_req("A"),
]),
_req("A"),
), (
RequirementAnd([
_req("A"),
_req("A"),
]),
_req("A"),
),
(
RequirementOr([
RequirementAnd([
_req("A"),
RequirementOr([_req("A"),
RequirementOr([_req("A")])])
]),
RequirementAnd([
_req("A"),
RequirementOr([
_req("A"),
RequirementOr([]),
]),
]),
]),
_req("A"),
),
(
RequirementOr([
RequirementAnd([
_req("A"),
RequirementOr([_req("A"),
RequirementOr([_req("A")])])
]),
RequirementAnd([
_req("A"),
RequirementOr([
_req("A"),
RequirementOr([_req("A")]),
])
])
]),
_req("A"),
)
]
for original, expected in test_parameters:
simplified = original.simplify()
assert simplified == expected
assert simplified.as_set(database) == expected.as_set(database)