def _cm_max_motive(motive_name: str,
opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
if not CMMotiveUtils().can_translate_motive(sim_info, motive_name):
output(
'Invalid motive: Valid motives for \'{}\' are as follows:'.format(
CommonSimNameUtils.get_full_name(sim_info)))
for motive in CMMotiveUtils().get_valid_motives(sim_info):
output('- {}'.format(motive))
return False
output('Setting motive \'{}\' to \'{}\' for \'{}\''.format(
motive_name, 100.0, CommonSimNameUtils.get_full_name(sim_info)))
result = CMMotiveUtils().change_motive_level(sim_info, motive_name, 100.0)
if not result:
output('Failed to set motive level.')
else:
output('Success!')
output('Done')
def _show(
self,
sim_info: SimInfo,
target_sim_info: SimInfo,
on_ok_selected: Callable[[UiDialogOkCancel], bool]=CommonFunctionUtils.noop,
on_cancel_selected: Callable[[UiDialogOkCancel], bool]=CommonFunctionUtils.noop
):
self.log.format_with_message(
'Attempting to display dialog.',
sim=CommonSimNameUtils.get_full_name(sim_info),
target=CommonSimNameUtils.get_full_name(target_sim_info)
)
_dialog = self._create_dialog(sim_info, target_sim_info)
if _dialog is None:
self.log.debug('Failed to create dialog.')
return
def _on_option_selected(dialog: UiDialogOkCancel) -> bool:
try:
self.log.debug('Option selected.')
if dialog.accepted:
self.log.debug('Ok chosen.')
return on_ok_selected(dialog)
self.log.debug('Cancel chosen.')
return on_cancel_selected(dialog)
except Exception as ex:
self.log.error('Error occurred on choosing an option.', exception=ex)
return False
_dialog.add_listener(_on_option_selected)
self.log.debug('Displaying dialog.')
_dialog.show_dialog()
def _show(
self,
sim_info: SimInfo,
target_sim_info: SimInfo,
on_ok_selected: Callable[[UiDialogOkCancel], Any]=CommonFunctionUtils.noop,
on_cancel_selected: Callable[[UiDialogOkCancel], Any]=CommonFunctionUtils.noop
):
self.log.format_with_message(
'Attempting to display dialog.',
sim=CommonSimNameUtils.get_full_name(sim_info),
target=CommonSimNameUtils.get_full_name(target_sim_info)
)
_dialog = self._create_dialog(sim_info, target_sim_info)
if _dialog is None:
self.log.debug('Failed to create dialog.')
return
@CommonExceptionHandler.catch_exceptions(self.mod_identity.name)
def _on_option_selected(dialog: UiDialogOkCancel):
self.log.debug('Option selected.')
if dialog.accepted:
self.log.debug('Ok chosen.')
return on_ok_selected(dialog)
self.log.debug('Cancel chosen.')
return on_cancel_selected(dialog)
_dialog.add_listener(_on_option_selected)
self.log.debug('Displaying dialog.')
_dialog.show_dialog()
def add_sim_to_target_household(
sim_info: SimInfo,
target_sim_info: SimInfo,
destroy_if_empty_household: bool = True) -> bool:
"""add_sim_to_active_household(sim_info, destroy_if_empty_household=True)
Add a Sim to the Household of the Target Sim.
:param sim_info: The Sim to add.
:type sim_info: SimInfo
:param target_sim_info: This Sim will receive the Sim to their Household.
:type target_sim_info: SimInfo
:param destroy_if_empty_household: If True, if the Sim comes from a household containing only them, then it will be destroyed after they are moved.
:type destroy_if_empty_household: bool, optional
:return: True, if the Sim was added to the household of the target successfully. False, if not.
:rtype: bool
"""
log.info('Adding Sim to target Sim household.')
destination_household = target_sim_info.household
log.format_info(
'Adding Sim to household of target sim',
sim=CommonSimNameUtils.get_full_name(sim_info),
target_sim=CommonSimNameUtils.get_full_name(target_sim_info),
destination_household=destination_household)
return CommonHouseholdUtils.move_sim_to_household(
sim_info,
household_id=destination_household.id,
destroy_if_empty_household=destroy_if_empty_household)
def is_available_for(self,
source_sim_info: SimInfo,
target: Any = None) -> bool:
self.log.debug(
'Checking if OC menu is available for \'{}\' and Target \'{}\'.'
.format(CommonSimNameUtils.get_full_name(source_sim_info),
target))
if target is None or not CommonTypeUtils.is_sim_or_sim_info(
target):
self.log.debug('Target is not a Sim.')
return False
if not OCSettingUtils.is_enabled_for_interactions(source_sim_info):
log.debug(
'Failed, Source Sim is not available for Outfit Customization.'
)
return False
target_sim_info = CommonSimUtils.get_sim_info(target)
if not OCSettingUtils.is_enabled_for_interactions(target_sim_info):
self.log.debug(
'Failed, Target Sim is not available for Outfit Customization.'
)
return False
self.log.debug(
'OC menu is available for Source Sim and Target Sim.')
return True
def on_started(self, interaction_sim: Sim,
interaction_target: Any) -> bool:
target_location = CommonObjectLocationUtils.get_location(
interaction_target)
def _on_submit(chosen_sim_info_list: Tuple[SimInfo]) -> None:
if chosen_sim_info_list is None or not chosen_sim_info_list:
return
for chosen_sim_info in chosen_sim_info_list:
# noinspection PyBroadException
try:
CommonSimSpawnUtils.hard_reset(
chosen_sim_info,
ResetReason.RESET_EXPECTED,
source=interaction_sim,
cause='S4CM: Teleporting Sim')
CommonSimLocationUtils.set_location(
chosen_sim_info, target_location)
except:
pass
dialog = CommonPremadeChooseSimsOptionDialog(
S4CMStringId.CHOOSE_SIMS_TO_TELEPORT,
0,
instanced_sims_only=True,
mod_identity=self.mod_identity)
if not dialog.has_options():
return False
# Sort the Sims in the dialog by their name.
dialog._internal_dialog._rows = tuple(
sorted(dialog._internal_dialog._rows,
key=lambda row: CommonSimNameUtils.get_full_name(
CommonSimUtils.get_sim_info(row.sim_id))))
dialog.show(on_submit=_on_submit, max_selectable=dialog.option_count)
return True
def on_started(self, interaction_sim: Sim,
interaction_target: Sim) -> bool:
self.log.format_with_message('Running \'{}\' on_started.'.format(
self.__class__.__name__),
interaction_sim=interaction_sim,
interaction_target=interaction_target)
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
from sims4communitylib.utils.sims.common_sim_interaction_utils import CommonSimInteractionUtils
from sims4communitylib.utils.resources.common_interaction_utils import CommonInteractionUtils
running_interaction_names = ', '.join(
CommonInteractionUtils.get_interaction_short_names(
CommonSimInteractionUtils.get_running_interactions_gen(
target_sim_info)))
queued_interaction_names = ', '.join(
CommonInteractionUtils.get_interaction_short_names(
CommonSimInteractionUtils.get_queued_interactions_gen(
target_sim_info)))
text = ''
text += 'Running Interactions:\n{}\n\n'.format(
running_interaction_names)
text += 'Queued Interactions:\n{}\n\n'.format(queued_interaction_names)
CommonBasicNotification(
CommonLocalizationUtils.create_localized_string(
'{} Running and Queued Interactions'.format(target_sim_name)),
CommonLocalizationUtils.create_localized_string(text)).show(
icon=IconInfoData(obj_instance=interaction_target))
return True
def _csf_reset_slider(slider_name: str,
opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
output('Resetting slider \'{}\'.'.format(slider_name))
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
output('Resetting slider for \'{}\'.'.format(
CommonSimNameUtils.get_full_name(sim_info)))
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
custom_sliders = CSFSliderQueryUtils().get_sliders_by_name(
sim_info, slider_name)
if not custom_sliders:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
custom_slider = next(iter(custom_sliders))
if custom_slider is not None:
output('Slider found.')
else:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
CSFCustomSliderApplicationService().reset_slider(sim_info, custom_slider)
output('Success, Sliders reset.')
def run(
self,
sim_info: SimInfo,
on_completed: Callable[[bool],
None] = CommonFunctionUtils.noop) -> bool:
def _on_chosen(chosen_sim_info: SimInfo) -> None:
if chosen_sim_info is None:
on_completed(False)
return
self.run_with_sims(sim_info,
chosen_sim_info,
on_completed=on_completed)
def _is_allowed(target_sim_info: SimInfo):
return self.can_run_with_sims(sim_info, target_sim_info)
dialog = CommonPremadeChooseSimOptionDialog(
S4CMSimControlMenuStringId.SET_FAMILY_RELATIONS,
0,
title_tokens=(sim_info, ),
include_sim_callback=_is_allowed,
instanced_sims_only=False,
mod_identity=ModInfo.get_identity(),
on_sim_chosen=_on_chosen,
on_close=lambda: on_completed(False))
if not dialog.has_options():
on_completed(False)
return False
# Sort the Sims in the dialog by their name.
dialog._internal_dialog._rows = tuple(
sorted(dialog._internal_dialog._rows,
key=lambda row: CommonSimNameUtils.get_full_name(
CommonSimUtils.get_sim_info(row.sim_id))))
dialog.show(sim_info=sim_info)
return True
def run(
self,
sim_info: SimInfo,
on_completed: Callable[[bool],
None] = CommonFunctionUtils.noop) -> bool:
def _on_submit(chosen_sim_info_list: Tuple[SimInfo]) -> None:
if chosen_sim_info_list is None or not chosen_sim_info_list:
on_completed(False)
return
on_completed(self._run_with_sims(sim_info, chosen_sim_info_list))
def _has_relationship(target_sim_info: SimInfo) -> bool:
return self.can_run_with_sims(sim_info, target_sim_info)
dialog = CommonPremadeChooseSimsOptionDialog(
S4CMSimControlMenuStringId.REMOVE_HAS_MET,
S4CMSimControlMenuStringId.CHOOSE_SIMS_TO_REMOVE_HAS_MET,
include_sim_callback=_has_relationship,
description_tokens=(sim_info, ),
instanced_sims_only=False,
mod_identity=self.mod_identity)
if not dialog.has_options():
return False
# Sort the Sims in the dialog by their name.
dialog._internal_dialog._rows = tuple(
sorted(dialog._internal_dialog._rows,
key=lambda row: CommonSimNameUtils.get_full_name(
CommonSimUtils.get_sim_info(row.sim_id))))
dialog.show(on_submit=_on_submit, max_selectable=dialog.option_count)
def _load(self, initial_outfit_parts: Dict[BodyType, int]=None) -> bool:
target_sim_name = CommonSimNameUtils.get_full_name(self.sim_info)
self._outfit_data: OutfitData = CommonOutfitUtils.get_outfit_data(self.sim_info, outfit_category_and_index=self._outfit_category_and_index)
if self._outfit_data is None:
self.log.error('Missing outfit data for Sim \'{}\' and Outfit Category and Index {}'.format(target_sim_name, self._outfit_category_and_index), throw=True)
return False
self._outfit_parts = CommonOutfitUtils.get_outfit_parts(self.sim_info, outfit_category_and_index=self._outfit_category_and_index)
self._original_outfit_data: FrozenSet[int] = frozenset(self._outfit_parts.items())
if initial_outfit_parts is not None:
for (key, value) in initial_outfit_parts.items():
if not isinstance(key, int) or not isinstance(value, int):
self.log.error('\'{}\': outfit_body_parts contains non-integer variables key: {} value: {}.'.format(target_sim_name, key, value))
return False
self._outfit_body_types = list(initial_outfit_parts.keys())
self._outfit_part_ids = list(initial_outfit_parts.values())
else:
if not self._outfit_data.part_ids or not self._outfit_data.body_types:
self.log.error('\'{}\' is missing outfit parts or body types for Outfit Category and Index {}.'.format(target_sim_name, self._outfit_category_and_index))
return False
self._outfit_body_types: List[Union[BodyType, int]] = list(self._outfit_data.body_types)
self._outfit_part_ids: List[int] = list(self._outfit_data.part_ids)
if len(self._outfit_body_types) != len(self._outfit_part_ids):
self.log.error('\'{}\': The number of outfit parts did not match the number of body types for Outfit Category and Index {}.'.format(target_sim_name, self._outfit_category_and_index))
return False
return True
def _common_fix_full_name_returning_empty_string(original, self: SimInfo, *_,
**__):
original_value = original(self, *_, **__)
if original_value == '':
return CommonSimNameUtils.get_full_name(
CommonSimUtils.get_sim_info(self))
return original_value
def open(self, sim_info: SimInfo):
""" Open the Change Motives dialog. """
self.log.debug('Opening change motives dialog for \'{}\'.'.format(
CommonSimNameUtils.get_full_name(sim_info)))
dialog = self._settings(sim_info)
if dialog is None:
return
dialog.show(sim_info=sim_info)
def __str__(self) -> str:
return '{}: {}, Age: {}, Gender: {}, Species: {}'.format(
self.__class__.__name__,
CommonSimNameUtils.get_full_name(self._sim_info),
CommonAgeUtils.get_age(self._sim_info),
CommonGenderUtils.get_gender(self._sim_info),
CommonSpecies.get_species(self._sim_info)
)
def _cgs_command_print_sim_data(_connection: int = None):
output = CheatOutput(_connection)
sim_info = CommonSimUtils.get_active_sim_info()
output('Sim Data for Sim: Name: \'{}\' Id: \'{}\''.format(
CommonSimNameUtils.get_full_name(sim_info),
CommonSimUtils.get_sim_id(sim_info)))
sim_storage = CGSSimData(sim_info)
for (key, value) in sim_storage._data.items():
output(' > {}: {}'.format(pformat(key), pformat(value)))
def apply(self, resend_outfits_after_apply: bool=True, change_sim_to_outfit_after_apply: bool=True, apply_to_all_outfits_in_same_category: bool=False, apply_to_outfit_category_and_index: Tuple[OutfitCategory, int]=None) -> bool:
"""apply(resend_outfits_after_apply=True, change_sim_to_outfit_after_apply=True, apply_to_all_outfits_in_same_category=False, apply_to_outfit_category_and_index=None)
Apply all changes made to the Outfit.
:param resend_outfits_after_apply: If set to True, the outfits of the Sim will be re-sent after changes have been applied. Default is True.
:type resend_outfits_after_apply: bool, optional
:param change_sim_to_outfit_after_apply: If set to True, the Sim will change to the outfit after the outfit is updated. Default is True.
:type change_sim_to_outfit_after_apply: bool, optional
:param apply_to_all_outfits_in_same_category: If set to True, changes will be applied to all Outfits in the same category. If set to False, changes will only be applied to the outfit provided at initialization. Default is False.
:type apply_to_all_outfits_in_same_category: bool, optional
:param apply_to_outfit_category_and_index: The OutfitCategory and Index to apply changes to. If set to None, it will be the OutfitCategory and Index provided at initialization. Default is None.
:type apply_to_outfit_category_and_index: Tuple[OutfitCategory, int], optional
:return: True, if changes were applied successfully. False, if not.
:rtype: bool
"""
sim_name = CommonSimNameUtils.get_full_name(self.sim_info)
self.log.format_with_message(
'Applying changes to outfit',
sim=sim_name,
resend_outfits=resend_outfits_after_apply,
change_to_outfit=change_sim_to_outfit_after_apply,
apply_to_all_outfits_in_same_category=apply_to_all_outfits_in_same_category,
apply_to_outfit_category_and_index=apply_to_outfit_category_and_index
)
apply_to_outfit_category_and_index = apply_to_outfit_category_and_index or self.outfit_category_and_index
saved_outfits = self.sim_info.save_outfits()
for saved_outfit in saved_outfits.outfits:
if int(saved_outfit.category) != int(apply_to_outfit_category_and_index[0]):
continue
if apply_to_all_outfits_in_same_category:
pass
else:
# noinspection PyUnresolvedReferences
sub_outfit_data = self._to_outfit_data(saved_outfit.body_types_list.body_types, saved_outfit.parts.ids)
if int(saved_outfit.outfit_id) != int(self._outfit_data.outfit_id) or sub_outfit_data != self._original_outfit_data:
continue
saved_outfit.parts = S4Common_pb2.IdList()
# noinspection PyUnresolvedReferences
saved_outfit.parts.ids.extend(self._outfit_part_ids)
saved_outfit.body_types_list = Outfits_pb2.BodyTypesList()
# noinspection PyUnresolvedReferences
saved_outfit.body_types_list.body_types.extend(self._outfit_body_types)
if not apply_to_all_outfits_in_same_category:
break
self.sim_info._base.outfits = saved_outfits.SerializeToString()
if change_sim_to_outfit_after_apply:
self.sim_info._base.outfit_type_and_index = apply_to_outfit_category_and_index
else:
self.sim_info._base.outfit_type_and_index = self._current_outfit_category_and_index
self.log.format_with_message('Finished flushing outfit changes.', sim=sim_name)
if resend_outfits_after_apply:
return CommonOutfitUtils.resend_outfits(self.sim_info)
return True
def on_started(self, interaction_sim: Sim, interaction_target: Sim) -> bool:
self.log.format_with_message('Running \'{}\' on_started.'.format(self.__class__.__name__), interaction_sim=interaction_sim, interaction_target=interaction_target)
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
buff_id = CommonSimPregnancyUtils.get_in_labor_buff(target_sim_info)
if buff_id != -1:
self.log.debug('The baby wants out now! Labor induced in \'{}\'. Chosen buff identifier: {}'.format(target_sim_name, str(buff_id)))
return CommonBuffUtils.add_buff(target_sim_info, buff_id)
self.log.debug('Failed to induce labor in \'{}\'.'.format(target_sim_name))
return False
def get_sliders_for_sim(
self,
sim_info: SimInfo,
slider_category: CSFSliderCategory = None,
ignore_sliders: Tuple[str] = (),
additional_tags: Tuple[str] = (),
additional_filters: Iterator[CSFSliderTagFilter] = ()
) -> Tuple[CSFSlider]:
"""get_sliders_for_sim(\
sim_info,\
slider_category=None,\
ignore_sliders=(),\
additional_tags=(),\
additional_filters=()\
)
Retrieve Sliders using the criteria.
:param sim_info: An instance of a Sim
:type sim_info: SimInfo
:param slider_category: The category of slider. If not specified, sliders will not be filtered by category. Default is None.
:type slider_category: CSFSliderCategory, optional
:param additional_tags: Additional tags to add to the query. Default is an empty collection.
:type additional_tags: Tuple[Any], optional
:param ignore_sliders: A collection of identifiers to ignore. Default is an empty collection.
:type ignore_sliders: Tuple[str], optional
:param additional_filters: Additional filters. Default is an empty collection.
:type additional_filters: Iterator[CSFSliderTagFilter], optional.
:return: A collection of Sliders matching the criteria.
:rtype: Tuple[CSFSlider]
"""
self.log.format_with_message(
'Get Sliders for Sim.',
sim_name=CommonSimNameUtils.get_full_name(sim_info),
slider_category=slider_category,
additional_filters=tuple(additional_filters),
ignore_sliders=ignore_sliders,
additional_tags=additional_tags)
filters: Tuple[CSFSliderTagFilter] = (
CSFSimDetailsSliderFilter(sim_info),
CSFTagsSliderFilter(additional_tags), *tuple(additional_filters))
if slider_category is not None:
filters = (
*filters,
CSFSliderCategorySliderFilter(slider_category),
)
# Include Object Tag, Include Category Tag
queries: Tuple[CSFSliderQuery] = (self._query_registry.create_query(
filters, query_type=CSFQueryType.ALL_PLUS_ANY), )
return tuple(self._query_registry.get_sliders(queries))
def _csf_reset_sliders(opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
output('Resetting all sliders.')
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
output('Resetting all sliders for \'{}\'.'.format(
CommonSimNameUtils.get_full_name(sim_info)))
CSFCustomSliderApplicationService().reset_all_sliders(sim_info)
output('Success, Sliders reset.')
def is_available_for(self,
source_sim_info: SimInfo,
target: Any = None) -> bool:
self.log.debug(
'Checking if Change Motives dialog is available for \'{}\' and Target \'{}\'.'
.format(CommonSimNameUtils.get_full_name(source_sim_info),
target))
if target is None or not CommonTypeUtils.is_sim_or_sim_info(
target):
self.log.debug('Target is not a Sim.')
return False
self.log.debug(
'Change Motives menu is available for Source Sim and Target Sim.'
)
return True
def run(
self,
sim_info: SimInfo,
on_completed: Callable[[bool],
None] = CommonFunctionUtils.noop) -> bool:
if CommonSimPregnancyUtils.is_pregnant(sim_info):
on_completed(False)
return False
if not CommonSimPregnancyUtils.can_impregnate(
sim_info) and not CommonSimPregnancyUtils.can_be_impregnated(
sim_info):
on_completed(False)
return False
def _on_chosen(chosen_sim_info: SimInfo) -> None:
if chosen_sim_info is None:
on_completed(False)
return
result = CommonSimPregnancyUtils.start_pregnancy(
sim_info, chosen_sim_info)
on_completed(result)
def _can_create_pregnancy(partner_sim_info: SimInfo) -> bool:
if sim_info is partner_sim_info:
return False
return S4CMSimPregnancyUtils.can_create_pregnancy_together(
sim_info, partner_sim_info)
dialog = CommonPremadeChooseSimOptionDialog(
S4CMSimControlMenuStringId.WHO_WILL_IMPREGNATE_SIM,
0,
title_tokens=(sim_info, ),
include_sim_callback=_can_create_pregnancy,
instanced_sims_only=False,
mod_identity=ModInfo.get_identity(),
on_sim_chosen=_on_chosen,
on_close=lambda: on_completed(False))
if not dialog.has_options():
on_completed(False)
return False
# Sort the Sims in the dialog by their name.
dialog._internal_dialog._rows = tuple(
sorted(dialog._internal_dialog._rows,
key=lambda row: CommonSimNameUtils.get_full_name(
CommonSimUtils.get_sim_info(row.sim_id))))
dialog.show(sim_info=sim_info)
return True
def _cm_max_all_motives(opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
output('Setting all motives to maximum for \'{}\''.format(
CommonSimNameUtils.get_full_name(sim_info)))
result = CMMotiveUtils().max_all_motives(sim_info)
if not result:
output('Failed to set motive level.')
else:
output('Success!')
output('Done')
def _csf_apply_slider(slider_name: str,
amount: float,
opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
output('Applying slider \'{}\' with amount \'{}\''.format(
slider_name, amount))
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
output('Applying slider to \'{}\'.'.format(
CommonSimNameUtils.get_full_name(sim_info)))
facial_attributes = PersistenceBlobs_pb2.BlobSimFacialCustomizationData()
facial_attributes.MergeFromString(sim_info.facial_attributes)
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
custom_sliders = CSFSliderQueryUtils().get_sliders_by_name(
sim_info, slider_name)
if not custom_sliders:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
custom_slider = next(iter(custom_sliders))
if custom_slider is not None:
output('Slider found.')
else:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
# noinspection PyBroadException
try:
amount = float(amount)
except:
output('Amount must be a number! \'{}\''.format(amount))
return False
output('Applying Sim Attributes!')
return CSFCustomSliderApplicationService().apply_slider(
sim_info, custom_slider, amount)
def _update_kwargs(self, **kwargs: Any) -> Dict[str, Any]:
if not kwargs:
return kwargs
new_kwargs: Dict[str, Any] = dict()
from sims4communitylib.utils.common_type_utils import CommonTypeUtils
from sims4communitylib.utils.sims.common_sim_name_utils import CommonSimNameUtils
from sims4communitylib.utils.sims.common_sim_utils import CommonSimUtils
for (key, val) in kwargs.items():
if CommonTypeUtils.is_sim_or_sim_info(val):
sim_info = CommonSimUtils.get_sim_info(val)
if sim_info is None:
new_kwargs[key] = val
else:
new_kwargs[key] = '{} ({})'.format(CommonSimNameUtils.get_full_name(sim_info), str(CommonSimUtils.get_sim_id(sim_info)))
else:
new_kwargs[key] = val
return new_kwargs
def _update_args(self, *args: Any) -> Tuple[Any]:
if not args:
return args
from sims4communitylib.utils.common_type_utils import CommonTypeUtils
from sims4communitylib.utils.sims.common_sim_name_utils import CommonSimNameUtils
from sims4communitylib.utils.sims.common_sim_utils import CommonSimUtils
new_args: List[Any] = list()
for arg in args:
if CommonTypeUtils.is_sim_or_sim_info(arg):
sim_info = CommonSimUtils.get_sim_info(arg)
if sim_info is None:
new_args.append(arg)
else:
new_args.append('{} ({})'.format(CommonSimNameUtils.get_full_name(sim_info), str(CommonSimUtils.get_sim_id(sim_info))))
else:
new_args.append(arg)
return tuple(new_args)
def on_started(self, interaction_sim: Sim, interaction_target: Sim) -> bool:
self.log.format_with_message(
'Running \'{}\' on_started.'.format(self.__class__.__name__),
interaction_sim=interaction_sim,
interaction_target=interaction_target
)
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
sim_situations = ', '.join(CommonSituationUtils.get_situation_names(CommonSimSituationUtils.get_situations(target_sim_info)))
text = ''
text += 'Running Situations:\n{}\n\n'.format(sim_situations)
CommonBasicNotification(
CommonLocalizationUtils.create_localized_string('{} Running Situations'.format(target_sim_name)),
CommonLocalizationUtils.create_localized_string(text)
).show(
icon=IconInfoData(obj_instance=interaction_target)
)
return True
def create_from_sim(cls, sim_info: SimInfo,
template_name: str) -> 'CSFSliderTemplate':
"""Create a template from a chosen Sim."""
from cncustomsliderframework.custom_slider_application_service import CSFCustomSliderApplicationService
slider_application_service = CSFCustomSliderApplicationService()
slider_to_value_library: Dict[str, float] = dict()
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
for slider in CSFSliderQueryUtils().get_sliders_for_sim(sim_info):
slider_identifier = slider.unique_identifier
if slider_identifier in slider_to_value_library:
continue
slider_value = slider_application_service.get_current_slider_value(
sim_info, slider)
slider_to_value_library[slider_identifier] = slider_value
return cls(template_name, CommonSimNameUtils.get_full_name(sim_info),
CommonAge.get_age(sim_info),
CommonSpecies.get_species(sim_info),
slider_to_value_library)
def on_test(cls, interaction_sim: Sim, interaction_target: Any, interaction_context: InteractionContext, **kwargs) -> TestResult:
cls.get_log().format_with_message('Running \'{}\' on_test.'.format(cls.__name__), interaction_sim=interaction_sim, interaction_target=interaction_target, interaction_context=interaction_context, kwargles=kwargs)
if interaction_target is None or not CommonTypeUtils.is_sim_or_sim_info(interaction_target):
cls.get_log().debug('Target is not a Sim.')
return TestResult.NONE
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
if not CommonSimPregnancyUtils.can_be_impregnated(target_sim_info):
cls.get_log().debug('\'{}\' cannot be impregnated and thus cannot be pregnant.')
return TestResult.NONE
if not hasattr(target_sim_info, 'pregnancy_tracker'):
cls.get_log().debug('Target does not have a pregnancy tracker.')
return TestResult.NONE
cls.get_log().debug('Checking if \'{}\' is pregnant.'.format(target_sim_name))
if not CommonSimPregnancyUtils.is_pregnant(target_sim_info):
cls.get_log().format_with_message('\'{}\' is not pregnant.'.format(target_sim_name))
return cls.create_test_result(False, reason='\'{}\' is not pregnant.'.format(target_sim_name), tooltip=CommonLocalizationUtils.create_localized_tooltip(CommonStringId.S4CL_SIM_IS_NOT_PREGNANT, tooltip_tokens=(target_sim_info, )))
cls.get_log().debug('Success.')
return TestResult.TRUE
def on_started(self, interaction_sim: Sim,
interaction_target: Sim) -> bool:
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
from sims4communitylib.utils.sims.common_sim_interaction_utils import CommonSimInteractionUtils
from sims4communitylib.utils.resources.common_interaction_utils import CommonInteractionUtils
running_interaction_strings: List[str] = list()
for interaction in CommonSimInteractionUtils.get_running_interactions_gen(
target_sim_info):
interaction_name = CommonInteractionUtils.get_interaction_short_name(
interaction)
interaction_id = CommonInteractionUtils.get_interaction_id(
interaction)
running_interaction_strings.append('{} ({})'.format(
interaction_name, interaction_id))
running_interaction_strings = sorted(running_interaction_strings,
key=lambda x: x)
running_interaction_names = ', '.join(running_interaction_strings)
queued_interaction_strings: List[str] = list()
for interaction in CommonSimInteractionUtils.get_queued_interactions_gen(
target_sim_info):
interaction_name = CommonInteractionUtils.get_interaction_short_name(
interaction)
interaction_id = CommonInteractionUtils.get_interaction_id(
interaction)
queued_interaction_strings.append('{} ({})'.format(
interaction_name, interaction_id))
queued_interaction_strings = sorted(queued_interaction_strings,
key=lambda x: x)
queued_interaction_names = ', '.join(queued_interaction_strings)
text = ''
text += 'Running Interactions:\n{}\n\n'.format(
running_interaction_names)
text += 'Queued Interactions:\n{}\n\n'.format(queued_interaction_names)
CommonBasicNotification(
CommonLocalizationUtils.create_localized_string(
'{} Running and Queued Interactions ({})'.format(
target_sim_name,
CommonSimUtils.get_sim_id(target_sim_info))),
CommonLocalizationUtils.create_localized_string(text)).show(
icon=IconInfoData(obj_instance=interaction_target))
return True
def on_started(self, interaction_sim: Sim, interaction_target: Sim) -> bool:
target_sim_info = CommonSimUtils.get_sim_info(interaction_target)
target_sim_name = CommonSimNameUtils.get_full_name(target_sim_info)
trait_strings: List[str] = list()
for trait in CommonTraitUtils.get_traits(target_sim_info):
trait_name = CommonTraitUtils.get_trait_name(trait)
trait_id = CommonTraitUtils.get_trait_id(trait)
trait_strings.append('{} ({})'.format(trait_name, trait_id))
trait_strings = sorted(trait_strings, key=lambda x: x)
sim_traits = ', '.join(trait_strings)
text = ''
text += 'Traits:\n{}\n\n'.format(sim_traits)
CommonBasicNotification(
CommonLocalizationUtils.create_localized_string('{} Traits ({})'.format(target_sim_name, CommonSimUtils.get_sim_id(target_sim_info))),
CommonLocalizationUtils.create_localized_string(text)
).show(
icon=IconInfoData(obj_instance=interaction_target)
)
return True