async def _patches_for_pickup(self, provider_name: str, pickup: PickupEntry):
inventory_resources: CurrentResources = {
item: inv_item.capacity
for item, inv_item in self._inventory.items()
}
conditional = pickup.conditional_for_resources(inventory_resources)
if conditional.name is not None:
item_name = conditional.name
else:
item_name = pickup.name
resources_to_give = {}
add_resource_gain_to_current_resources(conditional.resources, inventory_resources)
add_resource_gain_to_current_resources(conditional.resources, resources_to_give)
add_resource_gain_to_current_resources(pickup.conversion_resource_gain(inventory_resources),
resources_to_give)
# Ignore item% for received items
resources_to_give.pop(self.game.resource_database.item_percentage, None)
patches = [
all_prime_dol_patches.adjust_item_amount_and_capacity_patch(self.patches.powerup_functions,
item.index, delta)
for item, delta in resources_to_give.items()
]
return patches, f"Received {item_name} from {provider_name}."
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_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",
PickupModel(echoes_resource_database.game_enum,
"AmmoModel"),
ItemCategory.TEMPLE_KEY,
ItemCategory.KEY,
progression=((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 == {
"game":
"prime2",
"pickups": [{
'provider_name': 'Other Name',
'pickup': 'C@fSK*4Fga_C{94xPb='
}]
}
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,
}
async def test_patches_for_pickup(connector: EchoesRemoteConnector,
version: EchoesDolVersion, mocker,
generic_item_category):
# Setup
mock_item_patch: MagicMock = mocker.patch(
"randovania.patching.prime.all_prime_dol_patches.adjust_item_amount_and_capacity_patch"
)
db = connector.game.resource_database
pickup = PickupEntry("Pickup",
0,
generic_item_category,
generic_item_category,
progression=tuple(),
extra_resources=(
(db.energy_tank, db.energy_tank.max_capacity),
(db.item_percentage, 1),
))
inventory = {
db.multiworld_magic_item: InventoryItem(0, 0),
db.energy_tank: InventoryItem(1, 1),
}
# Run
patches, message = await connector._patches_for_pickup(
"Someone", pickup, inventory)
# Assert
mock_item_patch.assert_called_once_with(
version.powerup_functions, RandovaniaGame.METROID_PRIME_ECHOES,
db.energy_tank.extra["item_id"], db.energy_tank.max_capacity)
assert patches == [mock_item_patch.return_value]
assert message == "Received Pickup from Someone."
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 _pickup() -> PickupEntry:
return PickupEntry(
name="Pickup",
model_index=0,
item_category=ItemCategory.MOVEMENT,
resources=(ConditionalResources(None, None, ()), ),
)
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 _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 create_artifact(artifact_index: int,
minimum_progression: int,
resource_database: ResourceDatabase,
) -> PickupEntry:
ARTIFACT_CATEGORY = ItemCategory(
name="artifact",
long_name="",
hint_details=("an ", "artifact"),
is_major=False,
is_key=True
)
return PickupEntry(
name=prime_items.ARTIFACT_NAMES[artifact_index],
progression=(
(resource_database.get_item(prime_items.ARTIFACT_ITEMS[artifact_index]), 1),
),
model=PickupModel(
game=resource_database.game_enum,
name=prime_items.ARTIFACT_MODEL[artifact_index],
),
item_category=ARTIFACT_CATEGORY,
broad_category=GENERIC_KEY_CATEGORY,
probability_offset=0.25,
required_progression=minimum_progression,
)
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_decode_pickup(client: NetworkClient, echoes_resource_database,
generic_item_category):
data = (
"h^WxYK%Bzb%4P&bZe?<3c~o*?ZgXa3a!qe!b!=sZ&dS`%<kH75DmyE4E0aqZ0!yPSX#yJyqboamlgnXlAeaHwx"
"y`|qjis5Tm5_m@(Ur7@&dS`%<kH75DmyE4E0aqZ0!yPSX#yJyqboamlgnXlAeaHwxy`|qjis5Tm5_m@(Ur6S-~"
)
expected_pickup = PickupEntry(
name="The Name",
model=PickupModel(
game=RandovaniaGame.METROID_PRIME_ECHOES,
name="EnergyTransferModule",
),
item_category=generic_item_category,
broad_category=generic_item_category,
progression=tuple(),
)
# # Uncomment this to encode the data once again and get the new bytefield if it changed for some reason
# from randovania.server.game_session import _base64_encode_pickup
# new_data = _base64_encode_pickup(expected_pickup, echoes_resource_database)
# assert new_data == data
# Run
pickup = _decode_pickup(data, echoes_resource_database)
# Assert
assert pickup == expected_pickup
def bit_pack_unpack(cls, decoder: BitPackDecoder, database: ResourceDatabase) -> PickupEntry:
helper = DatabaseBitPackHelper(database)
name = bitpacking.decode_string(decoder)
model = PickupModel(
game=RandovaniaGame.bit_pack_unpack(decoder, {}),
name=bitpacking.decode_string(decoder),
)
item_category = ItemCategory.bit_pack_unpack(decoder, {})
broad_category = ItemCategory.bit_pack_unpack(decoder, {})
progression = bitpacking.decode_tuple(decoder, helper.decode_resource_quantity)
extra_resources = bitpacking.decode_tuple(decoder, helper.decode_resource_quantity)
unlocks_resource = bitpacking.decode_bool(decoder)
resource_lock = None
if bitpacking.decode_bool(decoder):
resource_lock = helper.decode_resource_lock(decoder)
respects_lock = bitpacking.decode_bool(decoder)
probability_offset = BitPackFloat.bit_pack_unpack(decoder, _PROBABILITY_OFFSET_META)
probability_multiplier = BitPackFloat.bit_pack_unpack(decoder, _PROBABILITY_MULTIPLIER_META)
return PickupEntry(
name=name,
model=model,
item_category=item_category,
broad_category=broad_category,
progression=progression,
extra_resources=extra_resources,
unlocks_resource=unlocks_resource,
resource_lock=resource_lock,
respects_lock=respects_lock,
probability_offset=probability_offset,
probability_multiplier=probability_multiplier,
)
def create_dark_temple_key(
key_number: int,
temple_index: int,
resource_database: ResourceDatabase,
) -> PickupEntry:
"""
Creates a Dark Temple Key
:param key_number:
:param temple_index: The index of the temple: Dark Agon, Dark Torvus, Hive Temple
:param resource_database:
:return:
"""
TEMPLE_KEY_CATEGORY = ItemCategory(name="temple_key",
long_name="",
hint_details=("a ", "red Temple Key"),
is_major=False,
is_key=True)
return PickupEntry(
name=echoes_items.DARK_TEMPLE_KEY_NAMES[temple_index].format(
key_number + 1),
progression=((resource_database.get_item(
echoes_items.DARK_TEMPLE_KEY_ITEMS[temple_index][key_number]),
1), ),
model=PickupModel(
game=resource_database.game_enum,
name=echoes_items.DARK_TEMPLE_KEY_MODEL,
),
item_category=TEMPLE_KEY_CATEGORY,
broad_category=GENERIC_KEY_CATEGORY,
probability_offset=3,
)
def test_add_pickup_to_state(state_game_data, empty_patches,
generic_item_category):
# Starting State
db = state_game_data.resource_database
starting_node = state_game_data.world_list.resolve_teleporter_connection(
empty_patches.game.starting_location)
s = state.State(ResourceCollection(), (), 99, starting_node, empty_patches,
None, state_game_data)
resource_a = db.item[0]
resource_b = db.item[1]
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 == ResourceCollection.from_dict(db, {
resource_a: 1,
resource_b: 1,
})
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_decode_pickup(client, echoes_resource_database):
data = (
b'\x88\xa8\xd0\xca@\x9c\xc2\xda\xca\xcc\x08\x8a\xdc\xca\xe4\xce'
b'\xf2\xa8\xe4\xc2\xdc\xe6\xcc\xca\xe4\x9a\xde\xc8\xea\xd8\xcaB\x00p')
expected_pickup = PickupEntry(
name="The Name",
model=PickupModel(
game=RandovaniaGame.PRIME2,
name="EnergyTransferModule",
),
item_category=ItemCategory.MOVEMENT,
broad_category=ItemCategory.MOVEMENT,
progression=tuple(),
)
# from randovania.bitpacking import bitpacking
# from randovania.network_common.pickup_serializer import BitPackPickupEntry
# new_data = bitpacking.pack_value(BitPackPickupEntry(expected_pickup, echoes_resource_database))
# assert new_data == data
# Run
pickup = multiworld_client._decode_pickup(data, echoes_resource_database)
# Assert
assert pickup == expected_pickup
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 assign_pickup_to_starting_items(self, pickup: PickupEntry) -> "State":
pickup_resources = ResourceCollection.from_resource_gain(
self.resource_database,
pickup.resource_gain(self.resources, force_lock=True))
# Make sure there's no item percentage on starting items
if self.resource_database.item_percentage is not None:
pickup_resources.remove_resource(
self.resource_database.item_percentage)
new_resources = self.resources.duplicate()
new_resources.add_resource_gain(pickup_resources.as_resource_gain())
new_patches = self.patches.assign_extra_initial_items(
pickup_resources.as_resource_gain())
tank_delta = _energy_tank_difference(new_resources, self.resources,
self.resource_database)
return State(
new_resources,
self.collected_resource_nodes,
self.energy + tank_delta * self.game_data.energy_per_tank,
self.node,
new_patches,
self,
self.game_data,
)
def create_energy_cell(
cell_index: int,
resource_database: ResourceDatabase,
) -> PickupEntry:
ENERGY_CELL_CATEGORY = ItemCategory(name="energy_cell",
long_name="",
hint_details=("an ", "energy cell"),
is_major=False,
is_key=True)
return PickupEntry(
name=f"Energy Cell {cell_index + 1}",
progression=((resource_database.get_item(
corruption_items.ENERGY_CELL_ITEMS[cell_index]), 1), ),
extra_resources=(
(resource_database.get_item(
corruption_items.ENERGY_CELL_TOTAL_ITEM), 1),
(resource_database.item_percentage, 1),
),
model=PickupModel(
game=resource_database.game_enum,
name=corruption_items.ENERGY_CELL_MODEL,
),
item_category=ENERGY_CELL_CATEGORY,
broad_category=GENERIC_KEY_CATEGORY,
probability_offset=0.25,
)
def create_ammo_expansion(
ammo: Ammo,
ammo_count: Sequence[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)]
if resource_database.item_percentage is not None:
resources.append((resource_database.item_percentage, 1))
return PickupEntry(
name=ammo.name,
progression=(),
extra_resources=tuple(resources),
model=PickupModel(
game=resource_database.game_enum,
name=ammo.model_name,
),
item_category=ammo.item_category,
broad_category=ammo.broad_category,
respects_lock=requires_major_item,
resource_lock=ammo.create_resource_lock(resource_database),
probability_multiplier=2,
)
def create_sky_temple_key(
key_number: int,
resource_database: ResourceDatabase,
) -> PickupEntry:
"""
:param key_number:
:param resource_database:
:return:
"""
SKY_TEMPLE_KEY_CATEGORY = ItemCategory(name="sky_temple_key",
long_name="",
hint_details=("a ",
"Sky Temple Key"),
is_major=False,
is_key=True)
return PickupEntry(
name="Sky Temple Key {}".format(key_number + 1),
progression=((resource_database.get_item(
echoes_items.SKY_TEMPLE_KEY_ITEMS[key_number]), 1), ),
model=PickupModel(
game=resource_database.game_enum,
name=echoes_items.SKY_TEMPLE_KEY_MODEL,
),
item_category=SKY_TEMPLE_KEY_CATEGORY,
broad_category=GENERIC_KEY_CATEGORY,
probability_offset=3,
)
def assign_pickup_to_starting_items(self, pickup: PickupEntry) -> "State":
pickup_resources = convert_resource_gain_to_current_resources(
pickup.resource_gain(self.resources))
# Make sure there's no item percentage on starting items
pickup_resources.pop(self.resource_database.item_percentage, None)
new_resources = copy.copy(self.resources)
add_resources_into_another(new_resources, pickup_resources)
new_patches = self.patches.assign_extra_initial_items(pickup_resources)
if self.patches.game_specific is not None:
energy_per_tank = self.patches.game_specific.energy_per_tank
else:
energy_per_tank = 100
return State(
new_resources,
self.collected_resource_nodes,
self.energy +
_energy_tank_difference(new_resources, self.resources,
self.resource_database) * energy_per_tank,
self.node,
new_patches,
self,
self.resource_database,
self.world_list,
)
def create_pickup_hint(
pickup_assignment: PickupAssignment,
world_list: WorldList,
precision: HintItemPrecision,
target: Optional[PickupTarget],
players_config: PlayersConfiguration,
include_owner: bool,
) -> PickupHint:
"""
:param pickup_assignment:
:param world_list:
:param precision:
:param target:
:param players_config:
:param include_owner:
:return:
"""
if target is None:
target = PickupTarget(
pickup=PickupEntry(
name="Energy Transfer Module",
progression=tuple(),
model=PickupModel(
game=RandovaniaGame.METROID_PRIME_ECHOES,
name="EnergyTransferModule",
),
item_category=USELESS_ITEM_CATEGORY,
broad_category=USELESS_ITEM_CATEGORY,
),
player=players_config.player_index,
)
if precision is HintItemPrecision.GENERAL_CATEGORY:
details = target.pickup.item_category.general_details
elif precision is HintItemPrecision.PRECISE_CATEGORY:
details = target.pickup.item_category.hint_details
elif precision is HintItemPrecision.BROAD_CATEGORY:
details = target.pickup.broad_category.hint_details
elif precision is HintItemPrecision.DETAILED:
details = _calculate_determiner(pickup_assignment, target.pickup,
world_list), target.pickup.name
elif precision is HintItemPrecision.NOTHING:
details = "an ", "item"
else:
raise ValueError(f"Unknown precision: {precision}")
determiner = Determiner(details[0])
player = None
if include_owner and players_config.is_multiworld:
player = players_config.player_names[target.player]
return PickupHint(determiner, player, details[1])
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 _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 add_pickup_to_state(state: State, pickup: PickupEntry):
"""
Modifies inplace the given state, adding the resources of the given pickup
:param state:
:param pickup:
:return:
"""
add_resource_gain_to_current_resources(pickup.resource_gain(state.resources, force_lock=True), state.resources)
def test_create_pickup_for(percentage: bool, echoes_resource_database):
# Setup
item_a = echoes_resource_database.get_item(10)
item_b = echoes_resource_database.get_item(15)
item_c = echoes_resource_database.get_item(18)
ammo_a = echoes_resource_database.get_item(40)
ammo_b = echoes_resource_database.get_item(42)
major_item = MajorItem(
name="The Item",
item_category=ItemCategory.MORPH_BALL,
broad_category=ItemCategory.MORPH_BALL_RELATED,
model_name="SuperModel",
progression=(10, 15, 18),
ammo_index=(40, 42),
required=False,
original_index=None,
probability_offset=5,
)
state = MajorItemState(
include_copy_in_original_location=False,
num_shuffled_pickups=0,
num_included_in_starting_items=0,
included_ammo=(10, 20),
)
if percentage:
extra_resources = (
(ammo_a, 10),
(ammo_b, 20),
(echoes_resource_database.item_percentage, 1),
)
else:
extra_resources = (
(ammo_a, 10),
(ammo_b, 20),
)
# Run
result = randovania.generator.item_pool.pickup_creator.create_major_item(major_item, state, percentage,
echoes_resource_database,
None, False)
# Assert
assert result == PickupEntry(
name="The Item",
model=PickupModel(echoes_resource_database.game_enum, "SuperModel"),
progression=(
(item_a, 1),
(item_b, 1),
(item_c, 1),
),
extra_resources=extra_resources,
item_category=ItemCategory.MORPH_BALL,
broad_category=ItemCategory.MORPH_BALL_RELATED,
probability_offset=5,
respects_lock=False,
)
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 _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), )), ),
)
