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_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 test_create_seeker_launcher(
ammo_quantity: int,
ammo_requires_major_item: bool,
echoes_item_database,
echoes_resource_database,
):
# Setup
missile = echoes_resource_database.get_item(44)
missile_launcher = echoes_resource_database.get_item(73)
seeker_launcher = echoes_resource_database.get_item(26)
temporary = echoes_resource_database.get_item(71)
state = MajorItemState(
include_copy_in_original_location=False,
num_shuffled_pickups=0,
num_included_in_starting_items=0,
included_ammo=(ammo_quantity, ),
)
# Run
result = randovania.generator.item_pool.pickup_creator.create_major_item(
echoes_item_database.major_items["Seeker Launcher"], state, True,
echoes_resource_database,
echoes_item_database.ammo["Missile Expansion"],
ammo_requires_major_item)
# Assert
locked_conditional = (
ConditionalResources("Seeker Launcher",
None,
resources=(
(seeker_launcher, 1),
(temporary, ammo_quantity),
(echoes_resource_database.item_percentage, 1),
)),
ConditionalResources("Seeker Launcher",
missile_launcher,
resources=(
(seeker_launcher, 1),
(missile, ammo_quantity),
(echoes_resource_database.item_percentage, 1),
)),
)
normal_resources = (ConditionalResources(
"Seeker Launcher",
None,
resources=(
(seeker_launcher, 1),
(missile, ammo_quantity),
(echoes_resource_database.item_percentage, 1),
)), )
assert result == PickupEntry(
name="Seeker Launcher",
resources=locked_conditional
if ammo_requires_major_item else normal_resources,
model_index=25,
item_category=ItemCategory.MISSILE,
broad_category=ItemCategory.MISSILE_RELATED,
)
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 test_create_ammo_expansion(requires_major_item: bool,
echoes_resource_database):
# Setup
primary_a = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 73)
ammo_a = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 40)
ammo_b = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 42)
temporary_a = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 71)
temporary_b = echoes_resource_database.get_by_type_and_index(
ResourceType.ITEM, 72)
ammo = Ammo(
name="The Item",
maximum=100,
items=(40, 42),
unlocked_by=73,
temporaries=(71, 72),
models=(10, 20),
)
ammo_count = [75, 150]
item_resources = (
(ammo_a, ammo_count[0]),
(ammo_b, ammo_count[1]),
(echoes_resource_database.item_percentage, 1),
)
temporary_resources = (
(temporary_a, ammo_count[0]),
(temporary_b, ammo_count[1]),
(echoes_resource_database.item_percentage, 1),
)
# Run
result = randovania.generator.item_pool.pickup_creator.create_ammo_expansion(
ammo, ammo_count, requires_major_item, echoes_resource_database)
# Assert
assert result == PickupEntry(
name="The Item",
model_index=10,
resources=(
ConditionalResources("Temporary Missile", None,
temporary_resources),
ConditionalResources("The Item", primary_a, item_resources),
) if requires_major_item else
(ConditionalResources(None, None, item_resources), ),
item_category=ItemCategory.EXPANSION,
probability_offset=0,
)
def create_details(self, original_index: PickupIndex,
pickup_target: PickupTarget, visual_pickup: PickupEntry,
model_style: PickupModelStyle, scan_text: str,
model: PickupModel) -> ExportedPickupDetails:
if pickup_target.player == self.players_config.player_index:
details = self.solo_creator.create_details(original_index,
pickup_target,
visual_pickup,
model_style, scan_text,
model)
return dataclasses.replace(details,
scan_text=f"Your {details.scan_text}")
else:
other_name = self.players_config.player_names[pickup_target.player]
return ExportedPickupDetails(
index=original_index,
scan_text=f"{other_name}'s {scan_text}",
hud_text=[
f"Sent {pickup_target.pickup.name} to {other_name}!"
],
conditional_resources=[
ConditionalResources(
name=None,
item=None,
resources=((self.multiworld_item,
original_index.index + 1), ),
)
],
conversion=[],
model=model,
other_player=True,
original_pickup=pickup_target.pickup,
)
async def test_patches_for_pickup(backend, mocker):
# Setup
mock_item_patch: MagicMock = mocker.patch(
"randovania.games.prime.all_prime_dol_patches.adjust_item_amount_and_capacity_patch")
backend.patches = dol_patcher.ALL_VERSIONS_PATCHES[0]
db = backend.game.resource_database
pickup = PickupEntry("Pickup", 0, ItemCategory.MISSILE, ItemCategory.MISSILE, (
ConditionalResources(None, None,
((db.energy_tank, db.energy_tank.max_capacity),
(db.item_percentage, 1)),
),
))
backend._inventory = {
db.multiworld_magic_item: InventoryItem(0, 0),
db.energy_tank: InventoryItem(1, 1),
}
# Run
patches, message = await backend._patches_for_pickup("Someone", pickup)
# Assert
mock_item_patch.assert_called_once_with(backend.patches.powerup_functions, db.energy_tank.index,
db.energy_tank.max_capacity)
assert patches == [mock_item_patch.return_value]
assert message == "Received Pickup from Someone."
def _pickup() -> PickupEntry:
return PickupEntry(
name="Pickup",
model_index=0,
item_category=ItemCategory.MOVEMENT,
resources=(ConditionalResources(None, None, ()), ),
)
def test_run_validated_hud_text():
# Setup
rng = MagicMock()
rng.randint.return_value = 0
details = pickup_exporter.ExportedPickupDetails(
index=PickupIndex(0),
scan_text="scan",
hud_text=["Energy Transfer Module acquired!"],
conditional_resources=[
ConditionalResources(None, None, ()),
],
conversion=[],
model=PickupModel(
game=RandovaniaGame.METROID_PRIME_ECHOES,
name="EnergyTransferModule",
),
other_player=False,
original_pickup=None,
)
# Run
data = patch_data_factory.echoes_pickup_details_to_patcher(details, rng)
# Assert
assert data['hud_text'] == ['Run validated!']
def test_game_session_request_pickups_one_action(
mock_session_description: PropertyMock,
mock_get_resource_database: MagicMock,
mock_get_pickup_target: MagicMock, flask_app, two_player_session,
echoes_resource_database):
# Setup
sio = MagicMock()
sio.get_current_user.return_value = database.User.get_by_id(1234)
pickup = PickupEntry(
"A", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY,
(ConditionalResources(None, None,
((echoes_resource_database.item[0], 1), )), ))
mock_get_pickup_target.return_value = PickupTarget(pickup=pickup, player=0)
mock_get_resource_database.return_value = echoes_resource_database
# Run
result = game_session.game_session_request_pickups(sio, 1)
# Assert
mock_get_resource_database.assert_called_once_with(
mock_session_description.return_value, 0)
mock_get_pickup_target.assert_called_once_with(
mock_session_description.return_value, 1, 0)
assert result == [{'provider_name': 'Other Name', 'pickup': '6c8P51ON~'}]
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_game_session_collect_pickup_for_self(
mock_session_description: PropertyMock,
mock_get_resource_database: MagicMock,
mock_get_pickup_target: MagicMock, mock_emit: MagicMock, flask_app,
two_player_session, echoes_resource_database):
sio = MagicMock()
sio.get_current_user.return_value = database.User.get_by_id(1234)
pickup = PickupEntry(
"A", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY,
(ConditionalResources(None, None,
((echoes_resource_database.item[0], 1), )), ))
mock_get_resource_database.return_value = echoes_resource_database
mock_get_pickup_target.return_value = PickupTarget(pickup, 0)
# Run
with flask_app.test_request_context():
result = game_session.game_session_collect_locations(sio, 1, (0, ))
# Assert
assert result is None
mock_emit.assert_not_called()
mock_get_pickup_target.assert_called_once_with(
mock_session_description.return_value, 0, 0)
with pytest.raises(peewee.DoesNotExist):
database.GameSessionTeamAction.get(session=two_player_session,
provider_row=0,
provider_location_index=0)
def test_create_hints_item_dark_temple_keys(empty_patches, players_config,
echoes_game_description, pickup,
indices, expected_message):
# Setup
db = echoes_game_description.resource_database
keys = [
(PickupIndex(index),
dataclasses.replace(pickup,
resources=(ConditionalResources(
None, None, ((db.get_item(item), 1), )), )))
for index, item in zip(indices, echoes_items.DARK_TEMPLE_KEY_ITEMS[1])
]
patches = dataclasses.replace(empty_patches,
pickup_assignment={
pickup_index: PickupTarget(key, 0)
for pickup_index, key in keys
})
hint = Hint(HintType.RED_TEMPLE_KEY_SET,
None,
dark_temple=HintDarkTemple.TORVUS_BOG)
# Run
result = item_hints.create_message_for_hint(
hint, {0: patches}, players_config, None, {},
echoes_game_description.world_list)
# Assert
assert result == expected_message
def _make_pickup(item_category: ItemCategory):
return PickupEntry(
name="Pickup",
model_index=0,
item_category=item_category,
broad_category=item_category,
resources=(ConditionalResources(None, None, ()), ),
)
def test_bit_pack_pickup_entry(has_convert: bool, echoes_resource_database):
# Setup
name = "Some Random Name"
if has_convert:
convert_resources = (ResourceConversion(
find_resource_info_with_long_name(echoes_resource_database.item,
"Morph Ball"),
find_resource_info_with_long_name(echoes_resource_database.item,
"Item Percentage")), )
else:
convert_resources = ()
pickup = PickupEntry(
name=name,
model_index=26,
item_category=ItemCategory.TEMPLE_KEY,
broad_category=ItemCategory.KEY,
resources=(ConditionalResources(
"Morph Ball",
None,
(
(find_resource_info_with_long_name(
echoes_resource_database.item, "Morph Ball"), 2),
(find_resource_info_with_long_name(
echoes_resource_database.item, "Item Percentage"), 5),
),
),
ConditionalResources(
"Grapple Beam",
find_resource_info_with_long_name(
echoes_resource_database.item, "Morph Ball"),
((find_resource_info_with_long_name(
echoes_resource_database.item,
"Grapple Beam"), 3), ),
)),
convert_resources=convert_resources)
# Run
encoded = bitpacking.pack_value(
BitPackPickupEntry(pickup, echoes_resource_database))
decoder = BitPackDecoder(encoded)
decoded = BitPackPickupEntry.bit_pack_unpack(decoder, name,
echoes_resource_database)
# Assert
assert pickup == decoded
def bit_pack_unpack(cls, decoder: BitPackDecoder, name: str,
database: ResourceDatabase) -> PickupEntry:
model_index = decoder.decode_single(255)
probability_offset = BitPackFloat.bit_pack_unpack(
decoder, _PROBABILITY_OFFSET_META)
probability_multiplier = BitPackFloat.bit_pack_unpack(
decoder, _PROBABILITY_MULTIPLIER_META)
item_category = ItemCategory.bit_pack_unpack(decoder, {})
broad_category = ItemCategory.bit_pack_unpack(decoder, {})
has_name = bitpacking.decode_bool(decoder)
num_conditional = decoder.decode_single(
MAXIMUM_PICKUP_CONDITIONAL_RESOURCES) + 1
conditional_resources = []
for i in range(num_conditional):
item_name = None # TODO: get the first resource name
if i > 0:
item_dependency = decoder.decode_element(database.item)
else:
item_dependency = None
resources = []
for _ in range(decoder.decode_single(MAXIMUM_PICKUP_RESOURCES +
1)):
resource = decoder.decode_element(database.item)
quantity = decoder.decode_single(255)
resources.append((resource, quantity))
if has_name:
if bitpacking.decode_bool(decoder):
item_name = name
else:
item_name = resources[0][0].long_name
conditional_resources.append(
ConditionalResources(
name=item_name,
item=item_dependency,
resources=tuple(resources),
))
num_convert = decoder.decode_single(MAXIMUM_PICKUP_CONVERSION + 1)
convert_resources = []
for i in range(num_convert):
source = decoder.decode_element(database.item)
target = decoder.decode_element(database.item)
convert_resources.append(ResourceConversion(source, target))
return PickupEntry(
name=name,
model_index=model_index,
item_category=item_category,
broad_category=broad_category,
resources=tuple(conditional_resources),
convert_resources=tuple(convert_resources),
probability_offset=probability_offset,
probability_multiplier=probability_multiplier,
)
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,
(ConditionalResources("A", None,
((resource_a, 1), )), ))
pickup_y = PickupEntry("Y", 2, ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
(ConditionalResources("B", None,
((resource_b, 1), )),
ConditionalResources("A", resource_b,
((resource_a, 5), ))))
pickup_z = PickupEntry("Z", 2, ItemCategory.SUIT,
ItemCategory.LIFE_SUPPORT,
(ConditionalResources("A", None,
((resource_a, 1), )),
ConditionalResources("B", resource_a,
((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 = patcher_file._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 _pickup(echoes_game_description) -> PickupEntry:
resource = echoes_game_description.resource_database.energy_tank
return PickupEntry(
name="Pickup",
model_index=0,
item_category=ItemCategory.MOVEMENT,
broad_category=ItemCategory.LIFE_SUPPORT,
resources=(ConditionalResources(None, None, ((resource, 2), )), ),
)
def create_ammo_expansion(
ammo: Ammo,
ammo_count: List[int],
requires_major_item: bool,
resource_database: ResourceDatabase,
) -> PickupEntry:
"""
Creates a Pickup for an expansion of the given ammo.
:param ammo:
:param ammo_count:
:param requires_major_item:
:param resource_database:
:return:
"""
resources = [(resource_database.get_item(item), count)
for item, count in zip(ammo.items, ammo_count)]
resources.append((resource_database.item_percentage, 1))
if ammo.unlocked_by is not None and requires_major_item:
temporary_resources = [
(resource_database.get_item(item), count)
for item, count in zip(ammo.temporaries, ammo_count)
]
temporary_resources.append((resource_database.item_percentage, 1))
conditional_resources = (
ConditionalResources(temporary_resources[0][0].long_name, None,
tuple(temporary_resources)),
ConditionalResources(ammo.name,
resource_database.get_item(ammo.unlocked_by),
tuple(resources)),
)
else:
conditional_resources = (ConditionalResources(None, None,
tuple(resources)), )
return PickupEntry(
name=ammo.name,
resources=conditional_resources,
model_index=ammo.models[0], # TODO: use a random model
item_category=ItemCategory.EXPANSION,
broad_category=ammo.broad_category,
)
def create_visual_etm() -> PickupEntry:
"""
Creates an ETM that should only be used as a visual pickup.
:return:
"""
return PickupEntry(
name="Unknown item",
resources=(ConditionalResources(None, None, tuple()), ),
model_index=USELESS_PICKUP_MODEL,
item_category=ItemCategory.ETM,
)
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_add_pickup_to_state(database):
# Starting State
s = state.State({}, (), 99, None, None, None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
resource_b = SimpleResourceInfo(2, "B", "B", ResourceType.ITEM)
p = PickupEntry("B", 2, ItemCategory.SUIT, (
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_prime1_pickup_details_to_patcher_shiny_missile(
prime1_resource_database, other_player: bool):
# Setup
rng = MagicMock()
rng.randint.return_value = 0
detail = pickup_exporter.ExportedPickupDetails(
index=PickupIndex(15),
scan_text="Your Missile Expansion. Provides 5 Missiles",
hud_text=["Missile Expansion acquired!"],
conditional_resources=[
ConditionalResources(
None,
None,
((prime1_resource_database.get_item_by_name("Missile"), 6), ),
)
],
conversion=[],
model=PickupModel(RandovaniaGame.METROID_PRIME, "Missile"),
other_player=other_player,
original_pickup=None,
)
if other_player:
shiny_stuff = {
'model': {
'game': 'prime1',
'name': 'Missile'
},
'scanText': 'Your Missile Expansion. Provides 5 Missiles',
'hudmemoText': 'Missile Expansion acquired!',
}
else:
shiny_stuff = {
'model': {
'game': 'prime1',
'name': 'Shiny Missile'
},
'scanText': 'Your Shiny Missile Expansion. Provides 5 Missiles',
'hudmemoText': 'Shiny Missile Expansion acquired!',
}
# Run
result = prime1_pickup_details_to_patcher(detail, False, rng)
# Assert
assert result == {
'type': 'Missile',
'currIncrease': 6,
'maxIncrease': 6,
'respawn': False,
**shiny_stuff,
}
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}
def test_state_with_pickup(database):
# Setup
starting = state.State({}, (), 99, None, None, None, database)
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
p = PickupEntry("A", 2, ItemCategory.SUIT,
(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}
def create_useless_pickup(resource_database: ResourceDatabase) -> PickupEntry:
"""
Creates an Energy Transfer Module pickup.
:param resource_database:
:return:
"""
return PickupEntry(
name="Energy Transfer Module",
resources=(ConditionalResources(
None, None,
tuple([(resource_database.get_item(USELESS_PICKUP_ITEM), 1)])), ),
model_index=USELESS_PICKUP_MODEL,
item_category=ItemCategory.ETM,
broad_category=ItemCategory.ETM,
)
def _conditional_resources_for_pickup(
pickup: PickupEntry) -> List[ConditionalResources]:
if len(pickup.progression) > 1:
assert pickup.resource_lock is None, pickup.name
return list(pickup.conditional_resources)
else:
resources = list(pickup.extra_resources)
name = pickup.name
if pickup.progression:
name = pickup.progression[0][0].long_name
resources.append(pickup.progression[0])
lock = pickup.resource_lock
if pickup.respects_lock and not pickup.unlocks_resource and lock is not None:
locked_resources = lock.convert_gain(resources)
return [
ConditionalResources(
name=f"Locked {name}",
item=None,
resources=tuple(locked_resources),
),
ConditionalResources(
name=name,
item=lock.locked_by,
resources=tuple(resources),
),
]
else:
return [
ConditionalResources(
name=name,
item=None,
resources=tuple(resources),
),
]
def create_artifact(
artifact_index: int,
resource_database: ResourceDatabase,
) -> PickupEntry:
return PickupEntry(
name=prime_items.ARTIFACT_NAMES[artifact_index],
resources=(ConditionalResources(
None, None,
tuple([(resource_database.get_item(
prime_items.ARTIFACT_ITEMS[artifact_index]), 1),
(resource_database.item_percentage, 1)])), ),
model_index=prime_items.ARTIFACT_MODEL[artifact_index],
item_category=ItemCategory.TEMPLE_KEY,
broad_category=ItemCategory.KEY,
probability_offset=0.25,
)
def test_decode_pickup(client, echoes_resource_database):
data = b'\x00\xc8@\x00'
expected_pickup = PickupEntry(
name="",
model_index=0,
item_category=ItemCategory.MOVEMENT,
broad_category=ItemCategory.MOVEMENT,
resources=(
ConditionalResources(None, None, ()),
),
)
# Run
pickup = client._decode_pickup(data)
# Assert
assert pickup == expected_pickup
def test_run_validated_hud_text():
# Setup
rng = MagicMock()
rng.randint.return_value = 0
creator = patcher_file.PickupCreatorSolo(rng, patcher_file._SimplifiedMemo())
resource_a = SimpleResourceInfo(1, "A", "A", ResourceType.ITEM)
pickup = PickupEntry("Energy Transfer Module", 1, ItemCategory.TEMPLE_KEY, ItemCategory.KEY,
(
ConditionalResources("Energy Transfer Module", None, ((resource_a, 1),)),
))
# Run
data = creator.create_pickup_data(PickupIndex(0), PickupTarget(pickup, 0), pickup, PickupModelStyle.ALL_VISIBLE,
"Scan Text")
# Assert
assert data['hud_text'] == ['Run validated!']