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 __init__(self,
on_close: Callable[[], None] = CommonFunctionUtils.noop):
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
super().__init__()
self._on_close = on_close
self.slider_application_service = CSFCustomSliderApplicationService()
self._slider_query_utils = CSFSliderQueryUtils()
def get_sliders(self,
sim_info: SimInfo) -> Iterator[Tuple[CSFSlider, float]]:
"""Retrieve sliders associated with this template."""
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
for (identifier, amount) in self._slider_to_value_library.items():
custom_slider = CSFSliderQueryUtils().locate_by_identifier(
identifier)
if custom_slider is None:
self.log.debug(
'No slider found with identifier: {}'.format(identifier))
continue
if not custom_slider.is_available_for(sim_info):
continue
yield custom_slider, amount
def reset_all_sliders(self, sim_info: SimInfo) -> bool:
""" Reset all Custom Sliders for a Sim. """
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
self.reset_slider(sim_info, custom_slider)
return True
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 get_current_slider_value_by_identifier(self, sim_info: SimInfo,
identifier: str) -> float:
""" Retrieve the current value of a slider by its identifier. """
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
custom_slider = CSFSliderQueryUtils().locate_by_identifier(identifier)
if custom_slider is None:
self.log.debug(
'No slider found with identifier: {}'.format(identifier))
return False
return self.get_current_slider_value(sim_info, custom_slider)
def apply_slider_by_identifier(self, sim_info: SimInfo, identifier: str,
amount: float) -> bool:
""" Apply a slider with its identifier. """
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
self.log.debug(
'Attempting to apply slider with identifier {} and amount {}'.
format(identifier, amount))
custom_slider = CSFSliderQueryUtils().locate_by_identifier(identifier)
if custom_slider is None:
self.log.debug(
'No slider found with identifier: {}'.format(identifier))
return False
self.log.debug('Slider found, attempting to apply.')
return self.apply_slider(sim_info, custom_slider, amount)
def get_current_slider_value_by_name(self, sim_info: SimInfo,
slider_name: str) -> float:
""" Retrieve the current value of a slider by its name. """
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
custom_sliders = CSFSliderQueryUtils().get_sliders_by_name(
sim_info, slider_name)
if not custom_sliders:
self.log.debug(
'No sliders found with name: {}'.format(slider_name))
return False
custom_slider = next(iter(custom_sliders))
if custom_slider is None:
self.log.debug('No slider found with name: {}'.format(slider_name))
return False
return self.get_current_slider_value(sim_info, custom_slider)
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 apply_slider_by_name(self, sim_info: SimInfo, name: str,
amount: float) -> bool:
""" Apply a slider with its name. """
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
self.log.debug(
'Attempting to apply slider with name {} and amount {}'.format(
name, amount))
custom_sliders = CSFSliderQueryUtils().get_sliders_by_name(
sim_info, name)
if not custom_sliders:
self.log.debug('No sliders found with name: {}'.format(name))
return False
custom_slider = next(iter(custom_sliders))
if custom_slider is None:
self.log.debug('No slider found with name: {}'.format(name))
return False
self.log.debug('Slider found, attempting to apply.')
return self.apply_slider(sim_info, custom_slider, amount)
def is_available_for(self,
source_sim_info: SimInfo,
target: Any = None) -> bool:
self.log.format_with_message(
'Checking if customize sliders are available for Source Sim and Target.',
source_sim=source_sim_info,
target=target)
if target is None or not CommonTypeUtils.is_sim_or_sim_info(
target):
self.log.debug('Failed, Target is not a Sim.')
return False
target_sim_info = CommonSimUtils.get_sim_info(target)
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
if not CSFSliderQueryUtils().has_sliders_for_sim(target_sim_info):
self.log.debug(
'Failed, No CSF sliders available for the Target Sim.')
return False
self.log.debug(
'CSF Menu is available for Source Sim and Target Sim.')
return True
def _csf_help(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
output('Available Sliders:')
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
for custom_slider in sorted(
CSFSliderQueryUtils().get_sliders_for_sim(sim_info),
key=lambda sl: sl.raw_display_name):
output('>{}'.format(custom_slider.raw_display_name))
output('Available Commands:')
output('csf.apply_slider <slider_name> <amount>')
output(
' >|apply the slider with <slider_name> in the amount of <amount>')
output('csf.reset_slider <slider_name>')
output(' >|reset the slider with name <slider_name> to 0.0')
output('csf.reset_sliders')
output(' >|reset all sliders to 0.0')
class CSFCustomizeSlidersDialog(HasLog):
""" A dialog for changing custom sliders. """
def __init__(self,
on_close: Callable[[], None] = CommonFunctionUtils.noop):
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
super().__init__()
self._on_close = on_close
self.slider_application_service = CSFCustomSliderApplicationService()
self._slider_query_utils = CSFSliderQueryUtils()
# noinspection PyMissingOrEmptyDocstring
@property
def mod_identity(self) -> CommonModIdentity:
return ModInfo.get_identity()
# noinspection PyMissingOrEmptyDocstring
@property
def log_identifier(self) -> str:
return 'csf_customize_sliders_dialog'
def open(self, sim_info: SimInfo, page: int = 1) -> None:
""" Open the dialog. """
self.log.format_with_message(
'Opening customize sliders dialog for Sim.', sim=sim_info)
def _on_close() -> None:
self.log.debug('Customize Slider dialog closed.')
if self._on_close is not None:
self._on_close()
option_dialog = CommonChooseObjectOptionDialog(
CSFStringId.CUSTOMIZE_SLIDERS,
CSFStringId.CHOOSE_SLIDERS_TO_MODIFY,
mod_identity=self.mod_identity,
on_close=_on_close,
per_page=400)
def _reopen_dialog() -> None:
self.log.debug('Reopening customize sliders dialog.')
self.open(sim_info, page=option_dialog.current_page)
option_dialog.add_option(
CommonDialogActionOption(
CommonDialogOptionContext(
CSFStringId.SLIDER_TEMPLATES_NAME,
CSFStringId.SLIDER_TEMPLATES_DESCRIPTION,
tag_list=[
slider_category.name
for slider_category in CSFSliderCategory.values
]),
on_chosen=lambda *_, **__: CSFSliderTemplateDialog(
on_close=_reopen_dialog).open(sim_info),
always_visible=True))
def _on_reset_all_sliders() -> None:
self.log.debug('Confirming all sliders reset.')
def _on_confirm(_) -> None:
self.log.debug('Resetting all sliders.')
self.slider_application_service.reset_all_sliders(sim_info)
_reopen_dialog()
def _on_cancel(_) -> None:
self.log.debug('Cancelled resetting of all sliders.')
_reopen_dialog()
CommonOkCancelDialog(
CSFStringId.CONFIRMATION,
CSFStringId.ARE_YOU_SURE_YOU_WANT_TO_RESET_ALL_SLIDERS,
mod_identity=self.mod_identity).show(
on_ok_selected=_on_confirm, on_cancel_selected=_on_cancel)
def _on_slider_changed(slider_unique_identifier: str, amount: float,
outcome: CommonChoiceOutcome):
if slider_unique_identifier is None or amount is None or CommonChoiceOutcome.is_error_or_cancel(
outcome):
self.log.debug(
'No slider chosen, dialog closed, or no amount specified.')
_reopen_dialog()
return
self.log.debug('Slider changed, attempting to apply.')
self.slider_application_service.apply_slider_by_identifier(
sim_info, slider_unique_identifier, amount)
_reopen_dialog()
self.log.debug('Opening Customize Slider dialog.')
option_dialog.add_option(
CommonDialogActionOption(
CommonDialogOptionContext(
CSFStringId.RESET_ALL_SLIDERS_NAME,
CSFStringId.RESET_ALL_SLIDERS_DESCRIPTION,
tag_list=[
slider_category.name
for slider_category in CSFSliderCategory.values
]),
on_chosen=lambda *_, **__: _on_reset_all_sliders(),
always_visible=True))
sliders: Tuple[
CSFSlider] = self._slider_query_utils.get_sliders_for_sim(sim_info)
if not sliders:
from cncustomsliderframework.sliders.slider_query_registry import CSFSliderQueryRegistry
if CSFSliderQueryRegistry()._collecting:
CommonOkDialog(
CSFStringId.SLIDERS_ARE_STILL_LOADING,
CSFStringId.SLIDERS_ARE_STILL_LOADING_DESCRIPTION,
description_tokens=(
CSFStringId.FINISHED_LOADING_SLIDERS, ),
mod_identity=ModInfo.get_identity()).show()
else:
CommonOkDialog(CSFStringId.NO_SLIDERS_FOUND,
CSFStringId.NO_SLIDERS_FOUND,
mod_identity=ModInfo.get_identity()).show()
_on_close()
return
self.log.debug('Adding slider count {}'.format(len(sliders)))
sorted_sliders = sorted(sliders, key=lambda s: s.name)
slider_categories: List[CSFSliderCategory] = list()
object_categories: List[str] = list()
for custom_slider in sorted_sliders:
for slider_category in custom_slider.categories:
if slider_category.name in object_categories:
continue
slider_categories.append(slider_category)
object_categories.append(slider_category.name)
def _on_randomize_slider_category(category_name: str,
category: CSFSliderCategory):
self.log.debug(
'Confirming reset of sliders in category {}.'.format(
category_name))
def _on_confirm(_) -> None:
self.log.debug(
'Randomizing all sliders in category {}.'.format(
category_name))
for slider in sorted_sliders:
if category not in slider.categories:
continue
self.slider_application_service.apply_random(
sim_info, slider)
_reopen_dialog()
def _on_cancel(_) -> None:
self.log.debug(
'Cancelled randomization of sliders in category {}.'.
format(category_name))
_reopen_dialog()
CommonOkCancelDialog(CSFStringId.CONFIRMATION,
CSFStringId.RANDOMIZE_SLIDER_CONFIRMATION,
mod_identity=self.mod_identity).show(
on_ok_selected=_on_confirm,
on_cancel_selected=_on_cancel)
for slider_category in slider_categories:
option_dialog.add_option(
CommonDialogSelectOption(
slider_category.name,
slider_category,
CommonDialogOptionContext(
CSFStringId.RANDOMIZE_SLIDER_NAME,
CSFStringId.RANDOMIZE_SLIDER_DESCRIPTION,
title_tokens=(slider_category.name, ),
description_tokens=(slider_category.name, ),
tag_list=[
slider_category.name
for slider_category in CSFSliderCategory.values
]),
on_chosen=_on_randomize_slider_category,
always_visible=True))
for custom_slider in sorted_sliders:
if custom_slider.description is not None:
# noinspection PyTypeChecker
option_description = CommonLocalizationUtils.create_localized_string(
custom_slider.description,
tokens=(str(0.0), str(custom_slider.minimum_value),
str(custom_slider.maximum_value)))
else:
# noinspection PyTypeChecker
option_description = CommonLocalizationUtils.create_localized_string(
CSFStringId.CHANGE_THE_SLIDER,
tokens=(custom_slider.display_name, ))
option_dialog.add_option(
CommonDialogInputFloatOption(
custom_slider.unique_identifier,
self.slider_application_service.get_current_slider_value(
sim_info, custom_slider),
CommonDialogOptionContext(
custom_slider.display_name,
option_description,
icon=custom_slider.icon_id or None,
tag_list=tuple([
category.name
for category in custom_slider.categories
])),
min_value=custom_slider.minimum_value,
max_value=custom_slider.maximum_value,
on_chosen=_on_slider_changed,
dialog_description_identifier=CSFStringId.DEFAULT_MIN_MAX,
dialog_description_tokens=(
option_description, str(0.0),
str(custom_slider.minimum_value),
str(custom_slider.maximum_value))))
categories: List[CommonDialogObjectOptionCategory] = list()
for category in object_categories:
# noinspection PyTypeChecker
categories.append(
CommonDialogObjectOptionCategory(
category, icon=CommonIconId.S4CLIB_UNFILLED_CIRCLE_ICON))
self.log.debug('Showing slider options.')
option_dialog.show(sim_info=sim_info, page=page, categories=categories)