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)