def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from self.randomization_mode.bit_pack_encode(metadata)
if self.excluded_indices:
yield from bitpacking.encode_bool(True)
yield from bitpacking.pack_sorted_array_elements(self._sorted_indices, _ALL_INDICES)
else:
yield from bitpacking.encode_bool(False)
def _encode_item_category(category: ItemCategory):
yield from bitpacking.encode_string(category.name)
yield from bitpacking.encode_string(category.long_name)
yield from bitpacking.encode_string(category.hint_details[0])
yield from bitpacking.encode_string(category.hint_details[1])
yield from bitpacking.encode_bool(category.is_major)
yield from bitpacking.encode_bool(category.is_key)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
items = self.database.item
has_name = any(cond.name is not None for cond in self.value.resources)
yield self.value.model_index, 255
yield from BitPackFloat(self.value.probability_offset).bit_pack_encode(_PROBABILITY_OFFSET_META)
yield from BitPackFloat(self.value.probability_multiplier).bit_pack_encode(_PROBABILITY_MULTIPLIER_META)
yield from self.value.item_category.bit_pack_encode({})
yield from bitpacking.encode_bool(has_name)
yield len(self.value.resources) - 1, MAXIMUM_PICKUP_CONDITIONAL_RESOURCES
for i, conditional in enumerate(self.value.resources):
if i > 0:
yield from bitpacking.pack_array_element(conditional.item, items)
yield len(conditional.resources), MAXIMUM_PICKUP_RESOURCES + 1
for resource, quantity in conditional.resources:
yield from bitpacking.pack_array_element(resource, items)
yield quantity, 255
if has_name:
yield from bitpacking.encode_bool(conditional.name == self.value.name)
yield len(self.value.convert_resources), MAXIMUM_PICKUP_CONVERSION + 1
for conversion in self.value.convert_resources:
yield from bitpacking.pack_array_element(conversion.source, items)
yield from bitpacking.pack_array_element(conversion.target, items)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
db = default_database.game_description_for(self.game)
yield from self.randomization_mode.bit_pack_encode(metadata)
if self.excluded_indices:
yield from bitpacking.encode_bool(True)
yield from bitpacking.pack_sorted_array_elements(self._sorted_indices, _all_indices(db))
else:
yield from bitpacking.encode_bool(False)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from self.global_level.bit_pack_encode(metadata)
encodable_levels = list(LayoutTrickLevel)
encodable_levels.remove(LayoutTrickLevel.MINIMAL_RESTRICTIONS)
for trick in sorted(TrickLevelConfiguration.all_possible_tricks()):
if trick in self.specific_levels:
yield from bitpacking.encode_bool(True)
yield from bitpacking.pack_array_element(self.specific_levels[trick], encodable_levels)
else:
yield from bitpacking.encode_bool(False)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from self.global_level.bit_pack_encode(metadata)
encodable_levels = list(LayoutTrickLevel)
encodable_levels.remove(LayoutTrickLevel.MINIMAL_LOGIC)
for trick in sorted(_all_trick_indices()):
if trick in self.specific_levels:
yield from bitpacking.encode_bool(True)
yield from bitpacking.pack_array_element(self.specific_levels[trick], encodable_levels)
else:
yield from bitpacking.encode_bool(False)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from bitpacking.encode_bool(self.minimal_logic)
encodable_levels = list(LayoutTrickLevel)
encodable_levels.remove(LayoutTrickLevel.NO_TRICKS)
encodable_levels.remove(LayoutTrickLevel.MINIMAL_LOGIC)
for trick in sorted(_all_tricks()):
level = self.level_for_trick(trick)
if level in encodable_levels:
yield from bitpacking.encode_bool(True)
yield from bitpacking.pack_array_element(
level, encodable_levels)
else:
yield from bitpacking.encode_bool(False)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
game_data = default_data.read_json_then_binary(self.game)[1]
yield from bitpacking.encode_bool(self.minimal_logic)
if self.minimal_logic:
return
encodable_levels = list(LayoutTrickLevel)
encodable_levels.remove(LayoutTrickLevel.DISABLED)
for trick in sorted(_all_tricks(game_data)):
has_trick = self.has_specific_level_for_trick(trick)
yield from bitpacking.encode_bool(has_trick)
if has_trick:
yield from bitpacking.pack_array_element(self.level_for_trick(trick), encodable_levels)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
resource_database = default_database.resource_database_for(self.game)
yield from bitpacking.encode_bool(self.minimal_logic)
if self.minimal_logic:
return
encodable_levels = list(LayoutTrickLevel)
encodable_levels.remove(LayoutTrickLevel.DISABLED)
for trick in _all_tricks(resource_database):
has_trick = self.has_specific_level_for_trick(trick)
yield from bitpacking.encode_bool(has_trick)
if has_trick:
yield from bitpacking.pack_array_element(
self.level_for_trick(trick), encodable_levels)
def _encode_preset(preset: Preset, manager: PresetManager):
"""
:param preset:
:param manager:
:return:
"""
# Is this a custom preset?
is_custom_preset = preset.base_preset_name is not None
if is_custom_preset:
reference_versioned = manager.preset_for_name(preset.base_preset_name)
if reference_versioned is None:
reference_versioned = manager.default_preset
reference_preset = reference_versioned.get_preset()
else:
reference_preset = preset
included_presets = [versioned.get_preset() for versioned in manager.included_presets]
yield from bitpacking.encode_bool(is_custom_preset)
yield from bitpacking.pack_array_element(reference_preset, included_presets)
if is_custom_preset:
yield from preset.patcher_configuration.bit_pack_encode(
{"reference": reference_preset.patcher_configuration})
yield from preset.layout_configuration.bit_pack_encode(
{"reference": reference_preset.layout_configuration})
yield _dictionary_byte_hash(preset.layout_configuration.game_data), 256
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
from randovania.interface_common.preset_manager import PresetManager
manager: PresetManager = metadata["manager"]
# Is this a custom preset?
is_custom_preset = self.base_preset_name is not None
if is_custom_preset:
reference_versioned = manager.included_preset_with_name(
self.base_preset_name)
if reference_versioned is None:
reference_versioned = manager.default_preset_for_game(
self.game)
reference = reference_versioned.get_preset()
else:
reference = self
included_presets = [
versioned.get_preset() for versioned in manager.included_presets
]
yield from bitpacking.encode_bool(is_custom_preset)
yield from bitpacking.pack_array_element(reference, included_presets)
if is_custom_preset:
yield from self.configuration.bit_pack_encode(
{"reference": reference.configuration})
yield _dictionary_byte_hash(self.configuration.game_data), 256
def bit_pack_encode(
self, item: MajorItem,
reference: "MajorItemState") -> Iterator[Tuple[int, int]]:
db = default_database.resource_database_for(item.game)
if item.progression:
main_index = item.progression[0]
else:
main_index = item.ammo_index[0]
main_item = db.get_item(main_index)
# original location
if item.original_index is not None:
yield from bitpacking.encode_bool(
self.include_copy_in_original_location)
# num shuffled
yield from bitpacking.encode_int_with_limits(self.num_shuffled_pickups,
DEFAULT_MAXIMUM_SHUFFLED)
# starting item
if main_item.max_capacity > 1:
yield from bitpacking.encode_int_with_limits(
self.num_included_in_starting_items,
(2, main_item.max_capacity + 1))
else:
yield self.num_included_in_starting_items, main_item.max_capacity + 1
# priority
yield from bitpacking.BitPackFloat(
self.priority).bit_pack_encode(PRIORITY_LIMITS)
# ammo index
assert len(self.included_ammo) == len(item.ammo_index)
if self.included_ammo:
custom_ammo = self.included_ammo != reference.included_ammo
yield from bitpacking.encode_bool(custom_ammo)
if custom_ammo:
all_equal = len(set(self.included_ammo)) == 1
if len(item.ammo_index) > 1:
yield from bitpacking.encode_bool(all_equal)
for ammo_index, ammo in zip(item.ammo_index,
self.included_ammo):
yield ammo, db.get_item(ammo_index).max_capacity + 1
if all_equal:
break
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
helper = DatabaseBitPackHelper(self.database)
yield from bitpacking.encode_string(self.value.name)
yield from self.value.model.game.bit_pack_encode({})
yield from bitpacking.encode_string(self.value.model.name)
yield from self.value.item_category.bit_pack_encode({})
yield from self.value.broad_category.bit_pack_encode({})
yield from bitpacking.encode_tuple(self.value.progression, helper.encode_resource_quantity)
yield from bitpacking.encode_tuple(self.value.extra_resources, helper.encode_resource_quantity)
yield from bitpacking.encode_bool(self.value.unlocks_resource)
yield from bitpacking.encode_bool(self.value.resource_lock is not None)
if self.value.resource_lock is not None:
yield from helper.encode_resource_lock(self.value.resource_lock)
yield from bitpacking.encode_bool(self.value.respects_lock)
yield from BitPackFloat(self.value.probability_offset).bit_pack_encode(_PROBABILITY_OFFSET_META)
yield from BitPackFloat(self.value.probability_multiplier).bit_pack_encode(_PROBABILITY_MULTIPLIER_META)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield self.current_version(), _PERMALINK_MAX_VERSION
yield self.seed_number, _PERMALINK_MAX_SEED
yield from bitpacking.encode_bool(self.spoiler)
yield from bitpacking.encode_int_with_limits(self.player_count, _PERMALINK_PLAYER_COUNT_LIMITS)
manager = PresetManager(None)
previous_unique_presets = []
for preset in self.presets.values():
yield from bitpacking.encode_bool(preset in previous_unique_presets)
if preset in previous_unique_presets:
yield from bitpacking.pack_array_element(preset, previous_unique_presets)
continue
previous_unique_presets.append(preset)
yield from _encode_preset(preset, manager)
def test_encode_bool(bool_fixture):
# Setup
value, encoded = bool_fixture
# Run
result = list(bitpacking.encode_bool(value))
# Assert
assert result == [encoded]
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
from randovania.layout import configuration_factory
templates = [
configuration_factory.get_vanilla_actual_translator_configurations(
),
configuration_factory.get_vanilla_colors_translator_configurations(
),
self.with_full_random().translator_requirement,
self.translator_requirement,
]
yield from bitpacking.encode_bool(self.fixed_gfmc_compound)
yield from bitpacking.encode_bool(self.fixed_torvus_temple)
yield from bitpacking.encode_bool(self.fixed_great_temple)
yield from bitpacking.pack_array_element(self.translator_requirement,
templates)
if templates.index(self.translator_requirement) == 3:
for translator in self.translator_requirement.values():
yield from translator.bit_pack_encode({})
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from bitpacking.encode_bool(self.progressive_suit)
yield from bitpacking.encode_bool(self.progressive_grapple)
default = MajorItemsConfiguration.default()
result: List[Tuple[int, MajorItem, MajorItemState]] = []
for i, (item, state) in enumerate(self.items_state.items()):
if state != default.items_state[item]:
result.append((i, item, state))
yield len(result), len(self.items_state)
for index, _, _ in result:
yield index, len(self.items_state)
for index, item, state in result:
yield from state.bit_pack_encode(item)
yield self.minimum_random_starting_items, RANDOM_STARTING_ITEMS_LIMIT
yield self.maximum_random_starting_items, RANDOM_STARTING_ITEMS_LIMIT
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield from encode_game_list(tuple(preset.game for preset in self.presets))
yield self.seed_number, _PERMALINK_MAX_SEED
yield from bitpacking.encode_bool(self.spoiler)
manager = PresetManager(None)
for preset in self.presets:
yield from preset.bit_pack_encode({"manager": manager})
for game in _get_unique_games(self.presets):
yield _game_db_hash(game), 256
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
default: AmmoConfiguration = metadata["reference"]
assert list(self.maximum_ammo.keys()) == list(
default.maximum_ammo.keys())
assert list(self.items_state.keys()) == list(
default.items_state.keys())
for this, reference in zip(self.maximum_ammo.values(),
default.maximum_ammo.values()):
is_different = this != reference
yield from bitpacking.encode_bool(is_different)
if is_different:
yield this, 256
for this, reference in zip(self.items_state.values(),
default.items_state.values()):
is_different = this != reference
yield from bitpacking.encode_bool(is_different)
if is_different:
yield from this.bit_pack_encode({})
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
default: AmmoConfiguration = metadata["reference"]
assert list(self.items_state.keys()) == list(
default.items_state.keys())
for ammo, this in self.items_state.items():
reference = default.items_state[ammo]
is_different = this != reference
yield from bitpacking.encode_bool(is_different)
if is_different:
yield from this.bit_pack_encode({
"ammo": ammo,
})
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
ammo: Ammo = metadata["ammo"]
db = default_database.resource_database_for(ammo.game)
for count, ammo_index in zip(self.ammo_count, ammo.items):
ammo_item = db.get_item(ammo_index)
yield from bitpacking.encode_int_with_limits(
count,
(ammo_item.max_capacity // 2, ammo_item.max_capacity + 1),
)
yield from bitpacking.encode_big_int(self.pickup_count)
if ammo.unlocked_by is not None:
yield from bitpacking.encode_bool(self.requires_major_item)
def bit_pack_encode(self, item: MajorItem) -> Iterator[Tuple[int, int]]:
# original location
yield int(self.include_copy_in_original_location), 2
# num shuffled
yield from bitpacking.encode_int_with_limits(self.num_shuffled_pickups,
DEFAULT_MAXIMUM_SHUFFLED)
# starting item
yield self.num_included_in_starting_items, (
ENERGY_TANK_MAXIMUM_COUNT
if item.item_category == ItemCategory.ENERGY_TANK else 2)
# ammo index
assert len(self.included_ammo) == len(item.ammo_index)
for ammo in self.included_ammo:
yield ammo, 256
# allowed_as_random_starting_item
yield from bitpacking.encode_bool(self.allowed_as_random_starting_item)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield self.current_version(), _PERMALINK_MAX_VERSION
yield self.seed_number, _PERMALINK_MAX_SEED
yield int(self.spoiler), 2
yield _dictionary_byte_hash(self.layout_configuration.game_data), 256
manager = PresetManager(None)
# Is this a custom preset?
is_custom_preset = self.preset.base_preset_name is not None
if is_custom_preset:
reference_preset = manager.preset_for_name(
self.preset.base_preset_name)
else:
reference_preset = self.preset
yield from bitpacking.encode_bool(is_custom_preset)
yield from bitpacking.pack_array_element(reference_preset,
manager.included_presets)
if is_custom_preset:
yield from self.patcher_configuration.bit_pack_encode(
{"reference": reference_preset.patcher_configuration})
yield from self.layout_configuration.bit_pack_encode(
{"reference": reference_preset.layout_configuration})
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
yield self.pickup_count, AmmoState.maximum_pickup_count()
yield from bitpacking.encode_bool(self.requires_major_item)
