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 encode_resource_lock(self, lock: ResourceLock):
yield from bitpacking.pack_array_element(lock.locked_by,
self.database.item)
yield from bitpacking.pack_array_element(lock.item_to_lock,
self.database.item)
yield from bitpacking.pack_array_element(lock.temporary_item,
self.database.item)
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
reference: MajorItemsConfiguration = metadata["reference"]
result: List[Tuple[int, MajorItem, MajorItemState]] = []
for i, (item, state) in enumerate(self.items_state.items()):
if state != reference.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)
# default_items
for category, default in self.default_items.items():
all_major = [
major for major in reference.items_state.keys()
if major.item_category == category
]
yield from bitpacking.pack_array_element(default, all_major)
# random starting items
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]]:
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 _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]]:
reference: MajorItemsConfiguration = metadata["reference"]
name_to_item: Dict[str, MajorItem] = {
item.name: item
for item in self.items_state.keys()
}
modified_items = sorted(item.name
for item, state in self.items_state.items()
if state != reference.items_state[item])
yield from bitpacking.pack_sorted_array_elements(
modified_items, sorted(name_to_item.keys()))
for item_name in modified_items:
item = name_to_item[item_name]
yield from self.items_state[item].bit_pack_encode(
item, reference=reference.items_state[item])
# default_items
for category, default in self.default_items.items():
all_major = [
major for major in reference.items_state.keys()
if major.item_category == category
]
yield from bitpacking.pack_array_element(default, all_major)
# random starting items
yield from bitpacking.encode_big_int(
self.minimum_random_starting_items)
yield from bitpacking.encode_big_int(
self.maximum_random_starting_items)
def test_array_elements_round_trip(element, array):
generator = bitpacking.pack_array_element(element, array)
b = bitpacking._pack_encode_results(list(generator))
decoder = bitpacking.BitPackDecoder(b)
decoded_element = decoder.decode_element(array)
assert element == decoded_element
def bit_pack_encode(self, metadata) -> Iterator[Tuple[int, int]]:
templates = [
_get_vanilla_actual_translator_configurations(),
_get_vanilla_colors_translator_configurations(),
self.with_full_random().translator_requirement,
self.translator_requirement,
]
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 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]]:
items = self.database.item
yield self.value.model_index, 255
yield from self.value.item_category.bit_pack_encode({})
yield int(any(cond.name is not None
for cond in self.value.resources)), 2
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
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]]:
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]]:
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]]:
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 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 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 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 test_pack_array_element_single():
assert len(list(bitpacking.pack_array_element("x", ["x"]))) == 0
def encode_resource_conversion(self, item: ResourceConversion):
yield from bitpacking.pack_array_element(item.source, self.database.item)
yield from bitpacking.pack_array_element(item.target, self.database.item)
def encode_resource_quantity(self, item: ResourceQuantity):
yield from bitpacking.pack_array_element(item[0], self.database.item)
assert item[1] <= item[0].max_capacity
yield item[1], item[0].max_capacity + 1
def test_pack_array_element_missing():
with pytest.raises(ValueError):
list(bitpacking.pack_array_element(5, [10, 25]))
