def test_add_pickup_to_state(state_game_data, empty_patches,
generic_item_category):
# Starting State
s = state.State({}, (), 99, None, empty_patches, None, state_game_data)
resource_a = ItemResourceInfo("A", "A", 10)
resource_b = ItemResourceInfo("B", "B", 10)
p = PickupEntry("B",
2,
generic_item_category,
generic_item_category,
progression=(
(resource_a, 1),
(resource_b, 1),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def _state_game_data() -> StateGameData:
return StateGameData(
Mock(energy_tank=ItemResourceInfo(42, "Energy Tank", "EnergyTank", 14,
None),
item_percentage=ItemResourceInfo(47, "Item Percentage",
"Percentage", 255, None)), None,
100)
def test_multi_create_pickup_data_for_self(pickup_for_create_pickup_data):
# Setup
solo = pickup_exporter.PickupExporterSolo(
pickup_exporter.GenericAcquiredMemo())
creator = pickup_exporter.PickupExporterMulti(
solo, MagicMock(), PlayersConfiguration(0, {
0: "You",
1: "Someone"
}))
model = MagicMock()
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
# Run
data = creator.create_details(
PickupIndex(10), PickupTarget(pickup_for_create_pickup_data,
0), pickup_for_create_pickup_data,
PickupModelStyle.ALL_VISIBLE, "Scan Text", model)
# Assert
assert data == pickup_exporter.ExportedPickupDetails(
index=PickupIndex(10),
scan_text="Your Scan Text",
hud_text=['A acquired!', 'B acquired!'],
conditional_resources=[
ConditionalResources("A", None, ((resource_a, 1), )),
ConditionalResources("B", resource_a, ((resource_b, 1), )),
],
conversion=[],
model=model,
)
def _create_pickup_data():
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
return PickupEntry("Cake", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY, (
ConditionalResources("Sugar", None, ((resource_a, 1), )),
ConditionalResources("Salt", resource_a, ((resource_b, 1), )),
))
def test_multi_create_pickup_data_for_other(pickup_for_create_pickup_data):
# Setup
multi = ItemResourceInfo(10, "Multiworld", "Multiworld", 30, None)
solo = pickup_exporter.PickupExporterSolo(
pickup_exporter.GenericAcquiredMemo())
creator = pickup_exporter.PickupExporterMulti(
solo, multi, PlayersConfiguration(0, {
0: "You",
1: "Someone"
}))
model = MagicMock()
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
# Run
data = creator.create_details(
PickupIndex(10), PickupTarget(pickup_for_create_pickup_data,
1), pickup_for_create_pickup_data,
PickupModelStyle.ALL_VISIBLE, "Scan Text", model)
# Assert
assert data == pickup_exporter.ExportedPickupDetails(
index=PickupIndex(10),
scan_text="Someone's Scan Text",
hud_text=['Sent Cake to Someone!'],
conditional_resources=[
ConditionalResources(None, None, ((multi, 11), )),
],
conversion=[],
model=model,
)
def test_assign_pickup_to_starting_items(empty_patches, state_game_data):
# Setup
starting = state.State({}, (), 99, None, empty_patches, None,
state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry(
"A",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=((resource_a, 5), ),
extra_resources=((state_game_data.resource_database.item_percentage,
1), ),
unlocks_resource=True,
resource_lock=ResourceLock(resource_a, resource_a, resource_b),
)
# Run
final = starting.assign_pickup_to_starting_items(p)
# Assert
assert final.patches.starting_items == {resource_a: 5, resource_b: 0}
assert final.resources == {resource_a: 5, resource_b: 0}
def test_solo_create_pickup_data(pickup_for_create_pickup_data):
# Setup
creator = pickup_exporter.PickupExporterSolo(pickup_exporter.GenericAcquiredMemo())
model = MagicMock()
resource_a = ItemResourceInfo(0, "A", "A", 10)
resource_b = ItemResourceInfo(1, "B", "B", 10)
# Run
data = creator.create_details(PickupIndex(10), PickupTarget(pickup_for_create_pickup_data, 0),
pickup_for_create_pickup_data, PickupModelStyle.ALL_VISIBLE,
"Scan Text", model)
# Assert
assert data == pickup_exporter.ExportedPickupDetails(
index=PickupIndex(10),
scan_text="Scan Text",
hud_text=['A acquired!', 'B acquired!'],
conditional_resources=[
ConditionalResources("A", None, ((resource_a, 1),)),
ConditionalResources("B", resource_a, ((resource_b, 1),)),
],
conversion=[],
model=model,
other_player=False,
original_pickup=pickup_for_create_pickup_data,
)
def _create_pickup_data(generic_item_category):
resource_a = ItemResourceInfo(0, "A", "A", 10)
resource_b = ItemResourceInfo(1, "B", "B", 10)
return PickupEntry("Cake", 1, generic_item_category, generic_item_category,
progression=(
(resource_a, 1),
(resource_b, 1),
))
def make_req(item_id: int):
return RequirementAnd([
ResourceRequirement(
ItemResourceInfo("Scan Visor", "Scan", 1, frozendict({"item_id": 9})), 1, False,
),
ResourceRequirement(
ItemResourceInfo("Other", "Other", 1, frozendict({"item_id": item_id})), 1, False,
),
])
def _logbook_node(request):
has_translator = request.param
scan_visor = ItemResourceInfo(1, "Scan", "S", 1, None)
translator = ItemResourceInfo(2, "Translator", "T", 1, None)
node = LogbookNode("Logbook", False, None, 0, 1000, scan_visor,
LoreType.LUMINOTH_LORE,
translator if has_translator else None, None)
return has_translator, scan_visor, translator, node
def _create_pickup_data():
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
return PickupEntry("Cake",
1,
ItemCategory.TEMPLE_KEY,
ItemCategory.KEY,
progression=(
(resource_a, 1),
(resource_b, 1),
))
def test_calculate_hud_text(order: Tuple[str, str]):
# Setup
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
pickup_x = PickupEntry("A",
1,
ItemCategory.TEMPLE_KEY,
ItemCategory.KEY,
progression=(((resource_a, 1), )))
pickup_y = PickupEntry("Y",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=(
(resource_b, 1),
(resource_a, 5),
))
pickup_z = PickupEntry("Z",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=(
(resource_a, 1),
(resource_b, 5),
))
memo_data = {
"A": "You got {A} of A",
"B": "You found {B} of B",
}
pickups = {
"X": pickup_x,
"Y": pickup_y,
"Z": pickup_z,
}
# Run
result = pickup_exporter._calculate_hud_text(pickups[order[0]],
pickups[order[1]],
PickupModelStyle.HIDE_ALL,
memo_data)
# Assert
if order[1] == "Y":
assert result == ["You found 1 of B"]
elif order[1] == "X":
assert result == ["You got 1 of A", "You got 1 of A"]
else:
assert result == ["You got 1 of A", "You found 5 of B"]
def test_add_resource_gain_to_current_resources_convert(blank_pickup):
# Setup
resource_a = ItemResourceInfo("A", "A", 10, None)
resource_b = ItemResourceInfo("B", "B", 10, None)
pickup = dataclasses.replace(
blank_pickup,
progression=(),
resource_lock=ResourceLock(resource_b, resource_b, resource_a),
unlocks_resource=True,
)
current_resources = {resource_a: 5}
# Run
add_resource_gain_to_current_resources(
pickup.resource_gain(current_resources), current_resources)
# Assert
assert current_resources == {resource_a: 0, resource_b: 5}
def test_add_resource_gain_to_current_resources_convert():
# Setup
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
pickup = PickupEntry(name="P1",
model_index=1,
item_category=ItemCategory.SUIT,
broad_category=ItemCategory.LIFE_SUPPORT,
resources=(ConditionalResources(None, None, ()), ),
convert_resources=(ResourceConversion(
resource_a, resource_b), ))
current_resources = {resource_a: 5}
# Run
add_resource_gain_to_current_resources(
pickup.resource_gain(current_resources), current_resources)
# Assert
assert current_resources == {resource_a: 0, resource_b: 5}
def test_add_pickup_to_state(database, patches):
# Starting State
s = state.State({}, (), 99, None, patches, None, database, None)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry("B", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT, (
ConditionalResources(None, None, ((resource_a, 1), )),
ConditionalResources(None, resource_a, ((resource_b, 1), )),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def test_calculate_hud_text(order: Tuple[str, str], generic_item_category):
# Setup
resource_a = ItemResourceInfo(0, "A", "A", 10)
resource_b = ItemResourceInfo(1, "B", "B", 10)
pickup_x = PickupEntry("A", 1, generic_item_category, generic_item_category,
progression=(
((resource_a, 1),)
))
pickup_y = PickupEntry("Y", 2, generic_item_category, generic_item_category,
progression=(
(resource_b, 1),
(resource_a, 5),
))
pickup_z = PickupEntry("Z", 2, generic_item_category, generic_item_category,
progression=(
(resource_a, 1),
(resource_b, 5),
))
memo_data = {
"A": "You got {A} of A",
"B": "You found {B} of B",
}
pickups = {
"X": pickup_x,
"Y": pickup_y,
"Z": pickup_z,
}
# Run
result = pickup_exporter._calculate_hud_text(pickups[order[0]], pickups[order[1]],
PickupModelStyle.HIDE_ALL, memo_data)
# Assert
if order[1] == "Y":
assert result == ["You found 1 of B"]
elif order[1] == "X":
assert result == ["You got 1 of A", "You got 1 of A"]
else:
assert result == ["You got 1 of A", "You found 5 of B"]
def test_extra_resources_maximum(generic_item_category):
item = ItemResourceInfo("Item", "Item", 2, None)
msg = "Attempt to give 5 of Item, more than max capacity"
with pytest.raises(ValueError, match=msg):
PickupEntry(name="broken",
model=PickupModel(RandovaniaGame.METROID_PRIME_ECHOES,
"Nothing"),
item_category=generic_item_category,
broad_category=generic_item_category,
progression=(),
extra_resources=((item, 5), ))
def _database() -> ResourceDatabase:
return ResourceDatabase(game_enum=RandovaniaGame.PRIME2,
item=[
ItemResourceInfo(0, "A", "A", 1, None),
ItemResourceInfo(1, "B", "B", 1, None),
ItemResourceInfo(2, "C", "C", 1, None),
],
event=[],
trick=[],
damage=[],
version=[],
misc=[
SimpleResourceInfo(0, "Trivial", "Trivial",
ResourceType.MISC),
SimpleResourceInfo(1, "Impossible",
"Impossible",
ResourceType.MISC),
],
requirement_template={},
energy_tank_item_index=0,
item_percentage_index=0,
multiworld_magic_item_index=0)
def _database() -> ResourceDatabase:
return ResourceDatabase(
game_enum=RandovaniaGame.METROID_PRIME_ECHOES,
item=[
ItemResourceInfo("A", "A", 1),
ItemResourceInfo("B", "B", 1),
ItemResourceInfo("C", "C", 1),
],
event=[],
trick=[],
damage=[],
version=[],
misc=[
SimpleResourceInfo("Trivial", "Trivial", ResourceType.MISC),
SimpleResourceInfo("Impossible", "Impossible", ResourceType.MISC),
],
requirement_template={},
damage_reductions={},
energy_tank_item_index="",
item_percentage_index=None,
multiworld_magic_item_index=None,
)
def test_collected_pickup_indices(database, patches):
# Setup
resources = {
ItemResourceInfo(1, "A", "A", 50, None): 5,
PickupIndex(1): 1,
PickupIndex(15): 1
}
s = state.State(resources, (), 99, None, patches, None, database, None)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [PickupIndex(1), PickupIndex(15)]
def test_state_with_pickup(database, patches):
# Setup
starting = state.State({}, (), 99, None, patches, None, database, None)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
p = PickupEntry("A", 2, ItemCategory.SUIT, ItemCategory.LIFE_SUPPORT,
(ConditionalResources(None, None, ((resource_a, 1), )), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == {resource_a: 1}
async def test_session_self_update(client: NetworkClient):
client._emit_with_result = AsyncMock()
client._current_game_session_meta = MagicMock()
client._current_game_session_meta.id = 1234
inventory: Inventory = {
ItemResourceInfo(33, "None", "None", 1): InventoryItem(1, 1)
}
await client.session_self_update(inventory, GameConnectionStatus.InGame,
MemoryExecutorChoice.DOLPHIN)
client._emit_with_result.assert_awaited_once_with(
"game_session_self_update",
(1234, b'\x01None\x00\x01\x01', "In-game (Dolphin)"))
def test_add_pickup_to_state(state_game_data, empty_patches):
# Starting State
s = state.State({}, (), 99, None, empty_patches, None, state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry("B",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=(
(resource_a, 1),
(resource_b, 1),
))
# Run
state.add_pickup_to_state(s, p)
state.add_pickup_to_state(s, p)
# Assert
assert s.resources == {
resource_a: 1,
resource_b: 1,
}
def test_sky_temple_key_distribution_logic_all_guardians_valid(
echoes_resource_database):
# Run
results = sky_temple_keys.add_sky_temple_key_distribution_logic(
echoes_resource_database, LayoutSkyTempleKeyMode.ALL_GUARDIANS)
item_pool, pickup_assignment, initial_items = results
# Assert
assert item_pool == []
assert initial_items == {
ItemResourceInfo(f'Sky Temple Key {i}', f'TempleKey{i}', 1,
frozendict({"item_id": item_ids[i - 1]})): 1
for i in range(4, 10)
}
assert list(pickup_assignment.keys()) == sky_temple_keys._GUARDIAN_INDICES
def test_assign_pickup_to_starting_items(patches, database):
# Setup
starting = state.State({}, (), 99, None, patches, None, database, None)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
resource_b = ItemResourceInfo(2, "B", "B", 10, None)
p = PickupEntry("A",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
resources=(ConditionalResources(None, None, (
(resource_a, 5),
(database.item_percentage, 1),
)), ),
convert_resources=(ResourceConversion(
resource_b, resource_a), ))
# Run
final = starting.assign_pickup_to_starting_items(p)
# Assert
assert final.patches.starting_items == {resource_a: 5, resource_b: 0}
assert final.resources == {resource_a: 5, resource_b: 0}
def test_collected_pickup_indices(state_game_data, empty_patches):
# Setup
resources = {
ItemResourceInfo("A", "A", 50, None): 5,
PickupIndex(1): 1,
PickupIndex(15): 1
}
s = state.State(resources, (), 99, None, empty_patches, None,
state_game_data)
# Run
indices = list(s.collected_pickup_indices)
# Assert
assert indices == [PickupIndex(1), PickupIndex(15)]
def test_sky_temple_key_distribution_logic_all_guardians_valid(
echoes_resource_database):
# Run
results = sky_temple_keys.add_sky_temple_key_distribution_logic(
echoes_resource_database, LayoutSkyTempleKeyMode.ALL_GUARDIANS)
item_pool, pickup_assignment, initial_items = results
# Assert
assert item_pool == []
assert initial_items == {
ItemResourceInfo(
randovania.games.prime.echoes_items.SKY_TEMPLE_KEY_ITEMS[i - 1],
f'Sky Temple Key {i}', f'TempleKey{i}', 1, None): 1
for i in range(4, 10)
}
assert list(pickup_assignment.keys()) == sky_temple_keys._GUARDIAN_INDICES
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 test_state_with_pickup(state_game_data, empty_patches):
# Setup
starting = state.State({}, (), 99, None, empty_patches, None,
state_game_data)
resource_a = ItemResourceInfo(1, "A", "A", 10, None)
p = PickupEntry("A",
2,
ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
progression=((resource_a, 1), ))
# Run
final = state.state_with_pickup(starting, p)
# Assert
assert final.previous_state is starting
assert final.resources == {resource_a: 1}
def test_sky_temple_key_distribution_logic_with_quantity(
echoes_resource_database, quantity: int):
# Run
results = sky_temple_keys.add_sky_temple_key_distribution_logic(
echoes_resource_database, LayoutSkyTempleKeyMode(quantity))
item_pool, pickup_assignment, initial_items = results
# Assert
assert item_pool == [
pickup_creator.create_sky_temple_key(i, echoes_resource_database)
for i in range(quantity)
]
assert pickup_assignment == {}
assert initial_items == {
ItemResourceInfo(f'Sky Temple Key {i}', f'TempleKey{i}', 1,
frozendict({"item_id": item_ids[i - 1]})): 1
for i in range(quantity + 1, 10)
}
