def __call__(self, test_targets=(), **kwargs):
for target in test_targets:
if self.outfit == self.OUTFIT_CURRENT:
outfit = target.get_current_outfit()
elif self.outfit == self.OUTFIT_PREVIOUS:
outfit = target.get_previous_outfit()
if any(outfit[0] == blacklist_category
for blacklist_category in self.blacklist_outfits):
return TestResult(
False,
'{} is wearing a blacklisted outfit category',
target,
tooltip=self.tooltip)
if self.whitelist_outfits and not any(
outfit[0] == whitelist_category
for whitelist_category in self.whitelist_outfits):
return TestResult(
False,
'{} is not wearing any whitelisted outfit category',
target,
tooltip=self.tooltip)
outfit_addition_test = self.outfit_addition_test
if outfit_addition_test is not None:
outfit_category = outfit_addition_test.outfit_category.get_outfit_category(
**kwargs)
outfits = target.get_outfits()
outfits_in_category = outfits.get_outfits_in_category(
outfit_category)
if outfit_addition_test.test_type == self.TEST_CAN_ADD:
if outfits_in_category is not None and len(
outfits_in_category
) >= get_maximum_outfits_for_category(outfit_category):
return TestResult(
False,
'{} cannot add a new {} outfit, but is required to be able to',
target,
outfit_category,
tooltip=self.tooltip)
elif outfit_addition_test.test_type == self.TEST_CANNOT_ADD:
if not outfits_in_category is None:
if len(outfits_in_category
) < get_maximum_outfits_for_category(
outfit_category):
return TestResult(
False,
'{} can add a new {} outfit, but is required not to not be able to',
target,
outfit_category,
tooltip=self.tooltip)
return TestResult(
False,
'{} can add a new {} outfit, but is required not to not be able to',
target,
outfit_category,
tooltip=self.tooltip)
return TestResult.TRUE
def __init__(self, interaction, sim_info, *args, **kwargs):
super().__init__(*args, **kwargs)
outfits = sim_info.get_outfits()
current_outfit = sim_info.get_current_outfit()
outfits_in_category = outfits.get_outfits_in_category(
self.outfit_category)
outfits_in_category = len(
outfits_in_category
) if outfits_in_category is not None else 0
if outfits_in_category >= get_maximum_outfits_for_category(
self.outfit_category):
available_outfits = [
(self.outfit_category, index)
for index in range(1, outfits_in_category)
if (self.outfit_category, index) != current_outfit
]
(_, outfit_index) = random.choice(available_outfits)
else:
(_, outfit_index) = outfits.get_next_outfit_for_category(
self.outfit_category)
sim_info.generate_outfit(outfit_category=self.outfit_category,
outfit_index=outfit_index,
filter_flag=OutfitFilterFlag.NONE)
self.entry_outfit = (self.outfit_category, outfit_index)
self.exit_outfit = None
def __init__(self, sim_info, outfit_source, *args, **kwargs):
super().__init__(*args, **kwargs)
source_outfit = outfit_source.get_current_outfit()
source_category = source_outfit[0]
source_outfits = outfit_source.get_outfits()
target_outfits = sim_info.get_outfits()
outfits_in_category = target_outfits.get_outfits_in_category(
source_category)
outfits_in_category = len(
outfits_in_category
) if outfits_in_category is not None else 0
current_outfit = sim_info.get_current_outfit()
if outfits_in_category >= get_maximum_outfits_for_category(
source_category):
available_outfits = [
(source_category, index)
for index in range(1, outfits_in_category)
if (source_category, index) != current_outfit
]
destination_outfit = random.choice(available_outfits)
else:
destination_outfit = target_outfits.get_next_outfit_for_category(
source_category)
sim_info.generate_merged_outfit(source_outfits.get_sim_info(),
destination_outfit,
current_outfit, source_outfit)
self.entry_outfit = destination_outfit
self.exit_outfit = None
def get_maximum_outfits_for_outfit_category(outfit_category):
'''
Returns maximum amount of outfits for an outfit category.
:param outfit_category: OutfitCategory -> outfit category
:return: int -> maximum number of outfits for the passed outfit category
'''
return get_maximum_outfits_for_category(outfit_category)
def _setup_outfit_list(
self,
outfit_list: Iterator[Tuple[OutfitCategory, int]],
exclude_outfit_categories: Tuple[OutfitCategory]
) -> Tuple[Tuple[OutfitCategory, int]]:
if outfit_list:
return tuple(outfit_list)
outfit_list: List[Tuple[OutfitCategory, int]] = list()
from sims.outfits.outfit_utils import get_maximum_outfits_for_category
for outfit_category in OutfitCategory.values:
if outfit_category in exclude_outfit_categories:
continue
outfit_index = 0
while outfit_index < get_maximum_outfits_for_category(outfit_category):
outfit_list.append((outfit_category, outfit_index))
outfit_index += 1
return tuple(outfit_list)
def _regenerate_every_outfit(self, sim_info: SimInfo) -> bool:
result = False
for occult_base_sim_info in CommonOccultUtils.get_sim_info_for_all_occults_gen(
sim_info, (OccultType.MERMAID, )):
for outfit_category in CommonOutfitUtils.get_all_outfit_categories(
):
for outfit_index in range(
get_maximum_outfits_for_category(outfit_category)):
if not CommonOutfitUtils.has_outfit(
occult_base_sim_info,
(outfit_category, outfit_index)):
continue
if CommonOutfitUtils.generate_outfit(
occult_base_sim_info,
outfit_category_and_index=(outfit_category,
outfit_index)):
result = True
if result:
CommonOutfitUtils.update_outfits(sim_info)
return result
def reconcile_mannequin_data_internal(self, is_add=False, is_loaded=False):
if self.outfit_sharing is None:
return
mannequin_group_sharing_mode = get_mannequin_group_sharing_mode()
mannequin_group_data = get_mannequin_group_data(self.outfit_sharing, self._sim_info_data)
if is_loaded:
if mannequin_group_sharing_mode == MannequinGroupSharingMode.ACCEPT_THEIRS:
mannequin_group_data.set_mannequin_data(self._sim_info_data)
for mannequin in mannequin_group_data:
if mannequin is not self:
mannequin._replace_outfits(self._sim_info_data)
mannequin._resend_mannequin_data()
return
if mannequin_group_sharing_mode == MannequinGroupSharingMode.ACCEPT_YOURS:
self._replace_outfits(mannequin_group_data.get_mannequin_data())
return
mannequin_data = mannequin_group_data.get_mannequin_data()
if mannequin_data is None:
mannequin_group_data.set_mannequin_data(self._sim_info_data)
if is_add:
mannequin_group_data.reconcile_mannequin_data()
return
else:
if is_add:
if mannequin_group_sharing_mode == MannequinGroupSharingMode.ACCEPT_MERGED:
for (outfit_category, outfit_list) in self._sim_info_data.get_all_outfits():
if outfit_category not in REGULAR_OUTFIT_CATEGORIES:
continue
for (outfit_index, outfit_data) in enumerate(outfit_list):
if mannequin_data.is_generated_outfit_duplicate_in_category(self._sim_info_data, (outfit_category, outfit_index)):
continue
outfits_in_category = mannequin_data.get_outfits_in_category(outfit_category)
if outfits_in_category is not None and len(outfits_in_category) >= get_maximum_outfits_for_category(outfit_category):
show_mannequin_group_sharing_warning_notification()
else:
mannequin_data.generate_merged_outfit(self._sim_info_data, mannequin_data.add_outfit(outfit_category, outfit_data), mannequin_data.get_current_outfit(), (outfit_category, outfit_index), preserve_outfit_flags=True)
mannequin_group_data.reconcile_mannequin_data()
return
if self.owner.id:
for outfit_category in REGULAR_OUTFIT_CATEGORIES:
self._sim_info_data.generate_merged_outfits_for_category(mannequin_data, outfit_category, preserve_outfit_flags=True)