def factory(resolver,
participant_type,
balloon_target_override=None,
**kwargs):
if resolver is None:
logger.callstack('Attempting to use a None resolver in an icon.',
level=LEVEL_ERROR,
owner='bosee')
return EMPTY_ICON_INFO_DATA
if balloon_target_override is not None:
return IconInfoData(obj_instance=balloon_target_override)
participant = resolver.get_participant(participant_type)
if participant is None:
logger.callstack(
'Unable to retrieve participant for holiday icon variant.',
level=LEVEL_ERROR,
owner='bosee')
return EMPTY_ICON_INFO_DATA
else:
holiday_tracker = participant.household.holiday_tracker
holiday_service = services.holiday_service()
if holiday_service is not None and holiday_tracker is not None and holiday_tracker.active_holiday_id is not None:
return IconInfoData(
icon_resource=holiday_service.get_holiday_display_icon(
holiday_tracker.active_holiday_id))
return EMPTY_ICON_INFO_DATA
def _on_rank_down(self):
current_rank = self.rank_level
self.send_rank_change_update_message(current_rank + 1, current_rank)
sim_info = self.tracker.owner.sim_info
rank_data = self.rank_tuning.get(current_rank)
rank_down_data = self.rank_down_notification_tuning.get(current_rank)
if rank_data is None:
logger.error(
'Sim {}: {} is trying to rank down to level {} but there is no rank tuning.',
sim_info, self, current_rank)
return
if self.can_show_notification(rank_down_data):
if rank_down_data.rank_down_notification is not None:
notification = rank_down_data.rank_down_notification(
sim_info, resolver=SingleSimResolver(sim_info))
icon_override = None if rank_data.icon is None else IconInfoData(
icon_resource=rank_data.icon)
notification.show_dialog(icon_override=icon_override,
secondary_icon_override=IconInfoData(
obj_instance=sim_info),
additional_tokens=(current_rank, ))
if rank_down_data.rank_down_screen_slam is not None:
rank_down_data.rank_down_screen_slam.send_screen_slam_message(
sim_info, sim_info, rank_data.rank_name, current_rank)
for bucks_type in self.associated_bucks_types:
bucks_tracker = BucksUtils.get_tracker_for_bucks_type(
bucks_type, owner_id=self.tracker.owner.id)
bucks_tracker.validate_perks(bucks_type, self.rank_level)
def factory(resolver,
participant_type,
balloon_target_override=None,
**kwargs):
if resolver is None:
logger.callstack('Attempting to use a None resolver in an icon.',
level=LEVEL_ERROR,
owner='rmccord')
return EMPTY_ICON_INFO_DATA
if balloon_target_override is not None:
return IconInfoData(obj_instance=balloon_target_override)
participant = resolver.get_participant(participant_type)
if participant is None:
logger.callstack(
'Unable to retrieve participant for Lifestyle Brand.',
level=LEVEL_ERROR,
owner='bosee')
return EMPTY_ICON_INFO_DATA
lifestyle_brand_tracker = participant.lifestyle_brand_tracker
if lifestyle_brand_tracker is None:
logger.callstack(
'Unable to find a Lifestyle Brand Tracker for the participant: {}',
participant,
level=LEVEL_ERROR,
owner='rfleig')
return EMPTY_ICON_INFO_DATA
lifestyle_brand_icon = lifestyle_brand_tracker.logo
if lifestyle_brand_icon is None:
logger.callstack(
'Unable to find a Lifestyle Brand Logo for the participant: {}',
participant,
level=LEVEL_ERROR,
owner='rfleig')
return EMPTY_ICON_INFO_DATA
return IconInfoData(icon_resource=lifestyle_brand_icon)
def _apply_to_subject_and_target(self, subject, target, resolver):
knowledge = subject.relationship_tracker.get_knowledge(target.sim_id,
initialize=True)
if knowledge is None:
return
trait_tracker = target.trait_tracker
if self.traits.learned_type == self.TRAIT_SPECIFIED:
traits = tuple(trait for trait in self.traits.potential_traits
if trait_tracker.has_trait(trait)
if trait not in knowledge.known_traits)
elif self.traits.learned_type == self.TRAIT_ALL:
traits = self._select_traits(knowledge, trait_tracker)
elif self.traits.learned_type == self.TRAIT_RANDOM:
traits = self._select_traits(knowledge,
trait_tracker,
random_count=self.traits.count)
if not traits and self.notification_no_more_traits is not None:
interaction = resolver.interaction
if interaction is not None:
self.notification_no_more_traits(
interaction).show_notification(
additional_tokens=(subject, target),
recipients=(subject, ),
icon_override=IconInfoData(obj_instance=target))
for trait in traits:
knowledge.add_known_trait(trait)
if traits:
interaction = resolver.interaction
if interaction is not None and self.notification is not None:
trait_string = LocalizationHelperTuning.get_bulleted_list(
None, *(trait.display_name(target) for trait in traits))
self.notification(interaction).show_notification(
additional_tokens=(subject, target, trait_string),
recipients=(subject, ),
icon_override=IconInfoData(obj_instance=target))
def create_pie_menu_message(sim, context, choice_menu, reference_id, pie_menu_action, target=None):
msg = interaction_protocol.PieMenuCreate()
msg.sim = sim.id if sim is not None else 0
msg.client_reference_id = reference_id
msg.server_reference_id = 0
if not choice_menu:
fire_service = services.get_fire_service()
if fire_service.fire_is_active:
msg.disabled_tooltip = fire_service.INTERACTION_UNAVAILABLE_DUE_TO_FIRE_TOOLTIP()
return msg
if pie_menu_action == PieMenuActions.INTERACTION_QUEUE_FULL_TOOLTIP:
msg.disabled_tooltip = PieMenuActions.INTERACTION_QUEUE_FULL_STR(sim)
return msg
create_tokens(msg.category_tokens, sim, target, None if target is None else target.get_stored_sim_info())
if choice_menu is not None:
msg.server_reference_id = choice_menu.revision
for (option_id, item) in choice_menu:
with ProtocolBufferRollback(msg.items) as item_msg:
item_msg.id = item.choice.aop_id
choice = item.choice
logger.debug('%3d: %s' % (option_id, choice))
name = choice.affordance.get_name(choice.target, context, **choice.interaction_parameters)
(name_override_tunable, name_override_result) = choice.affordance.get_name_override_tunable_and_result(target=choice.target, context=context)
if _make_pass:
name = InteractionCommandsTuning.MAKE_PASS_INTERACTION_NAME(name)
if _show_interaction_tuning_name:
affordance_tuning_name = str(choice.affordance.__name__)
name = InteractionCommandsTuning.INTERACTION_TUNING_NAME(name, affordance_tuning_name)
item_msg.loc_string = name
tooltip = item.result.tooltip
if tooltip is not None:
tooltip = choice.affordance.create_localized_string(tooltip, context=context, target=choice.target, **choice.interaction_parameters)
item_msg.disabled_text = tooltip
else:
success_tooltip = choice.affordance.get_display_tooltip(override=name_override_tunable, context=context, target=choice.target, **choice.interaction_parameters)
if success_tooltip is not None:
item_msg.success_tooltip = success_tooltip
pie_menu_icon = choice.affordance.pie_menu_icon
category_key = item.category_key
if name_override_tunable.new_pie_menu_icon is not None:
pie_menu_icon = name_override_tunable.new_pie_menu_icon
if name_override_tunable is not None and name_override_tunable.new_pie_menu_category is not None:
category_key = name_override_tunable.new_pie_menu_category.guid64
if pie_menu_icon is not None:
item_msg.icon_infos.append(create_icon_info_msg(IconInfoData(icon_resource=pie_menu_icon)))
if category_key is not None:
item_msg.category_key = category_key
if item.result.icon is not None:
item_msg.icon_infos.append(create_icon_info_msg(IconInfoData(icon_resource=item.result.icon)))
if choice.show_posture_incompatible_icon:
item_msg.icon_infos.append(create_icon_info_msg(IconInfoData(icon_resource=PieMenuActions.POSTURE_INCOMPATIBLE_ICON)))
handle_pie_menu_item_coloring(item_msg, item, sim, choice, name_override_result)
for visual_target in choice.affordance.visual_targets_gen(choice.target, context, **choice.interaction_parameters):
while visual_target is not None:
item_msg.target_ids.append(visual_target.id)
item_msg.score = item.choice.content_score if item.choice.content_score is not None else 0
item_msg.pie_menu_priority = choice.affordance.pie_menu_priority
return msg
def show_goal_awarded_notification(self):
if self.goal_awarded_notification is None:
return
icon_override = IconInfoData(icon_resource=self.display_icon)
secondary_icon_override = IconInfoData(obj_instance=self._sim_info)
notification = self.goal_awarded_notification(self._sim_info)
notification.show_dialog(
additional_tokens=self.get_localization_tokens(),
icon_override=icon_override,
secondary_icon_override=secondary_icon_override)
def on_chosen_from_service_picker(cls,
picker_interaction,
recurring=False):
sim = picker_interaction.sim
dialog = cls.recipe_picker_on_hire.picker_dialog(
sim, picker_interaction.get_resolver())
def on_recipe_selected(dialog):
recipe = dialog.get_single_result_tag()
if recipe is None or cls.hire_interaction is None:
return
cost = recipe.get_price(is_retail=True)
push_affordance = picker_interaction.generate_continuation_affordance(
cls.hire_interaction)
for aop in push_affordance.potential_interactions(
sim,
picker_interaction.context,
service_npc_user_specified_data_id=recipe.guid64,
service_npc_recurring_request=recurring):
aop.test_and_execute(picker_interaction.context)
for recipe in cls.recipe_picker_on_hire.recipes:
price = recipe.get_price(is_retail=True)
description = recipe.recipe_description(sim)
if recipe.has_final_product_definition:
recipe_icon = IconInfoData(
icon_resource=recipe.icon_override,
obj_def_id=recipe.final_product_definition_id,
obj_geo_hash=recipe.final_product_geo_hash,
obj_material_hash=recipe.final_product_material_hash)
else:
recipe_icon = IconInfoData(recipe.icon_override)
if sim.family_funds.money < price:
error_list = [CraftingTuning.INSUFFICIENT_FUNDS_TOOLTIP(sim)]
result = RecipeTestResult(enabled=False,
visible=False,
errors=error_list)
else:
result = True
row = RecipePickerRow(
name=recipe.get_recipe_name(sim),
price=price,
icon=recipe.icon_override,
row_description=description,
skill_level=recipe.required_skill_level,
is_enable=result,
linked_recipe=recipe.base_recipe,
display_name=recipe.get_recipe_picker_name(sim),
icon_info=recipe_icon,
tag=recipe)
dialog.add_row(row)
dialog.set_target_sim(sim)
dialog.show_dialog(on_response=on_recipe_selected)
def _apply_to_subject_and_target(self, subject, target, resolver):
degree_tracker = subject.degree_tracker
if degree_tracker is None:
return
empty_list_counter = 0
first_list_entry = True
active_scholarship_list = degree_tracker.get_scholarships_list_by_status(
ScholarshipStatus.ACTIVE, subject, first_list_entry)
if active_scholarship_list is None:
active_scholarship_list = LocalizationHelperTuning.get_raw_text('')
empty_list_counter += 1
else:
first_list_entry = False
pending_scholarships_list = degree_tracker.get_scholarships_list_by_status(
ScholarshipStatus.PENDING, subject, first_list_entry)
if pending_scholarships_list is None:
pending_scholarships_list = LocalizationHelperTuning.get_raw_text(
'')
empty_list_counter += 1
else:
first_list_entry = False
accepted_scholarships_list = degree_tracker.get_scholarships_list_by_status(
ScholarshipStatus.ACCEPTED, subject, first_list_entry)
if accepted_scholarships_list is None:
accepted_scholarships_list = LocalizationHelperTuning.get_raw_text(
'')
empty_list_counter += 1
else:
first_list_entry = False
rejected_scholarships_list = degree_tracker.get_scholarships_list_by_status(
ScholarshipStatus.REJECTED, subject, first_list_entry)
if rejected_scholarships_list is None:
rejected_scholarships_list = LocalizationHelperTuning.get_raw_text(
'')
empty_list_counter += 1
else:
first_list_entry = False
if empty_list_counter >= self.SCHOLARSHIP_STATUS_CATEGORIES_AMOUNT:
dialog = self.SCHOLARSHIP_STATUS_NO_SCHOLARSHIPS_NOTIFICATION(
subject, None)
dialog.show_dialog(
secondary_icon_override=IconInfoData(obj_instance=subject),
additional_tokens=(subject, ))
return
dialog = self.SCHOLARSHIP_STATUS_NOTIFICATION(subject, None)
dialog.show_dialog(
secondary_icon_override=IconInfoData(obj_instance=subject),
additional_tokens=(subject, active_scholarship_list,
pending_scholarships_list,
accepted_scholarships_list,
rejected_scholarships_list))
def factory(resolver, balloon_target_override=None, **kwargs):
if resolver is None:
logger.callstack('Attempting to use a None resolver in an icon.',
level=LEVEL_ERROR,
owner='rmccord')
return EMPTY_ICON_INFO_DATA
if balloon_target_override is not None:
return IconInfoData(obj_instance=balloon_target_override)
else:
privacy_liability = resolver.get_liability(PRIVACY_LIABILITY)
if privacy_liability:
violators = privacy_liability.privacy.violators
if violators:
return IconInfoData(
obj_instance=random.choice(list(violators)))
return EMPTY_ICON_INFO_DATA
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 display_scholarship_info(self, subject):
if self.SCHOLARSHIP_INFORMATION_SIGN.display_image is None or self.SCHOLARSHIP_INFORMATION_SIGN.background_image is None:
logger.error(
'Attempting to show scholarship sign to ({}) when content is None.',
subject)
return
sign_info = UI_pb2.DynamicSignView()
sign_info.name = self.SCHOLARSHIP_INFORMATION_SIGN.title
sign_info.image = sims4.resources.get_protobuff_for_key(
self.SCHOLARSHIP_INFORMATION_SIGN.display_image)
sign_info.background_image = sims4.resources.get_protobuff_for_key(
self.SCHOLARSHIP_INFORMATION_SIGN.background_image)
for sub_info in self.SCHOLARSHIP_INFORMATION_SIGN.sub_infos:
with ProtocolBufferRollback(sign_info.activities) as activity_msg:
if sub_info.icon is None:
logger.error(
'Attempting to show scholarship sign to ({}) when sub_info icon is None.',
subject)
continue
activity_msg.name = sub_info.name
activity_msg.description = sub_info.desc
activity_msg.icon = create_icon_info_msg(
IconInfoData(sub_info.icon))
distributor = Distributor.instance()
distributor.add_op(
subject.sim_info,
GenericProtocolBufferOp(Operation.DYNAMIC_SIGN_VIEW, sign_info))
services.get_event_manager().process_event(
TestEvent.ScholarshipInfoSignShown, sim_info=subject)
def perform(self, subject, target, resolver):
if subject is None:
logger.error(
'Trying to perform UniversityDynamicSignView op but subject is None. Resolver {}.',
resolver)
return
if not subject.is_sim:
logger.error(
'Trying to perform UniversityDynamicSignView op but subject {} is not Sim. Resolver {}.',
subject, resolver)
return
sign_info = UI_pb2.DynamicSignView()
sign_info.name = self.title
sign_info.image = sims4.resources.get_protobuff_for_key(
self.display_image)
sign_info.background_image = sims4.resources.get_protobuff_for_key(
self.background_image)
for sub_info in self.sub_infos:
with ProtocolBufferRollback(
sign_info.activities) as activity_msg:
activity_msg.name = sub_info.name
activity_msg.description = sub_info.desc.get_string(
subject.sim_info)
activity_msg.icon = create_icon_info_msg(
IconInfoData(sub_info.icon))
distributor = Distributor.instance()
distributor.add_op(
subject.sim_info,
GenericProtocolBufferOp(Operation.DYNAMIC_SIGN_VIEW,
sign_info))
def get_pie_menu_icon_info(cls,
inst,
target=DEFAULT,
context=DEFAULT,
icon=None,
**interaction_parameters):
return IconInfoData(icon)
def create_calendar_alert(self):
calendar_alert = super().create_calendar_alert()
if self.ui_display_data:
build_icon_info_msg(
IconInfoData(icon_resource=self.ui_display_data.icon),
self.ui_display_data.name, calendar_alert.calendar_icon)
return calendar_alert
def _send_relationship_data(self, sim_id):
if self.relationship_track_visual is None:
return
relationship_to_send = self._get_relationship(sim_id)
if not relationship_to_send:
return
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is None:
return
msg = commodity_protocol.RelationshipUpdate()
msg.actor_sim_id = sim_id
(msg.target_id.object_id,
msg.target_id.manager_id) = self.owner.icon_info
msg.target_instance_id = self.owner.id
if self.icon_override is not None:
build_icon_info_msg(IconInfoData(icon_resource=self.icon_override),
None, msg.target_icon_override)
with ProtocolBufferRollback(msg.tracks) as relationship_track_update:
relationship_value = relationship_to_send.get_value()
relationship_track_update.track_score = relationship_value
relationship_track_update.track_bit_id = self.relationship_track_visual.relationship_track.get_bit_at_relationship_value(
relationship_value).guid64
relationship_track_update.track_id = self.relationship_track_visual.relationship_track.guid64
relationship_track_update.track_popup_priority = self.relationship_track_visual.relationship_track.display_popup_priority
relationship_track_update.visible_in_relationship_panel = self.relationship_track_visual.visible_in_relationship_panel
send_relationship_op(sim_info, msg)
if self._object_social_mixin is not None:
self._object_social_mixin.send_social_update_message()
def __init__(self,
sim,
icon,
icon_object,
overlay,
balloon_type,
priority,
duration,
delay,
delay_randomization,
category_icon,
view_offset=None):
super().__init__()
self._sim_ref = sim.ref()
self.icon = icon
self.icon_object = icon_object
self.overlay = overlay
self.balloon_type = balloon_type
self.priority = priority
self.duration = duration
self.delay = delay
self.delay_randomization = delay_randomization
self.category_icon = create_icon_info_msg(
IconInfoData(icon_resource=category_icon[0],
obj_instance=category_icon[1])
) if category_icon is not None else None
self.view_offset = view_offset
def show_festival_info(cls):
if cls.festival_dynamic_sign_info is None:
return
ui_info = cls.festival_dynamic_sign_info
festival_info = UI_pb2.DynamicSignView()
festival_info.drama_node_guid = cls.guid64
festival_info.name = ui_info.festival_name
lot_id = cls.get_travel_lot_id()
persistence_service = services.get_persistence_service()
zone_id = persistence_service.resolve_lot_id_into_zone_id(lot_id, ignore_neighborhood_id=True)
zone_protobuff = persistence_service.get_zone_proto_buff(zone_id)
if zone_protobuff is not None:
festival_info.venue = LocalizationHelperTuning.get_raw_text(zone_protobuff.name)
festival_info.time = ui_info.festival_time
festival_info.image = sims4.resources.get_protobuff_for_key(ui_info.display_image)
festival_info.background_image = sims4.resources.get_protobuff_for_key(ui_info.background_image)
festival_info.action_label = ui_info.travel_to_festival_text
running_nodes = services.drama_scheduler_service().get_running_nodes_by_class(cls)
active_sim_info = services.active_sim_info()
if all(active_node.is_during_pre_festival() for active_node in running_nodes):
festival_info.disabled_tooltip = ui_info.festival_not_started_tooltip
elif any(active_node.is_on_festival_street() for active_node in running_nodes):
festival_info.disabled_tooltip = ui_info.on_street_tooltip
elif active_sim_info.is_in_travel_group():
festival_info.disabled_tooltip = ui_info.on_vacation_tooltip
for activity in ui_info.activity_info:
with ProtocolBufferRollback(festival_info.activities) as activity_msg:
activity_msg.name = activity.activity_name
activity_msg.description = activity.activity_description
activity_msg.icon = create_icon_info_msg(IconInfoData(activity.icon))
distributor = Distributor.instance()
distributor.add_op(active_sim_info, GenericProtocolBufferOp(Operation.DYNAMIC_SIGN_VIEW, festival_info))
def build_msg(self,
additional_tokens=(),
icon_override=DEFAULT,
event_id=None,
career_args=None,
**kwargs):
if icon_override is DEFAULT:
if self.participant is not None:
participant = self._resolver.get_participant(self.participant)
if participant is not None:
icon_override = IconInfoData(obj_instance=participant)
msg = super().build_msg(icon_override=icon_override,
additional_tokens=additional_tokens,
**kwargs)
msg.dialog_type = Dialog_pb2.UiDialogMessage.NOTIFICATION
notification_msg = msg.Extensions[
Dialog_pb2.UiDialogNotification.dialog]
notification_msg.expand_behavior = self.expand_behavior
notification_msg.criticality = self.urgency
notification_msg.information_level = self.information_level
notification_msg.visual_type = self.visual_type
if career_args is not None:
notification_msg.career_args = career_args
if self.primary_icon_response is not None:
self._build_response_arg(self.primary_icon_response,
notification_msg.primary_icon_response,
**kwargs)
if self.secondary_icon_response is not None:
self._build_response_arg(self.secondary_icon_response,
notification_msg.secondary_icon_response,
**kwargs)
return msg
def _on_yes_selected(_: Any):
from sims4controlmenu.dialogs.modify_sim_data.modify_skills.operations.set_skill_level import \
S4CMSetSkillLevelsSimOp
skill_manager = CommonResourceUtils.get_instance_manager(Types.STATISTIC)
sim = CommonSimUtils.get_sim_instance(sim_info)
for skill in skill_manager.get_ordered_types(only_subclasses_of=Skill):
skill: Skill = skill
if not S4CMSetSkillLevelsSimOp()._is_skill_allowed_for_modification(sim_info, skill):
continue
if not skill.can_add(sim):
self.verbose_log.format_with_message('Failed, Skill is not allowed for Sim.', skill=skill, sim=sim_info)
continue
skill_levels = tuple(range(0, skill.max_level + 1))
chosen_skill_level = random.choice(skill_levels)
if chosen_skill_level == 0:
if CommonSimSkillUtils.has_skill(sim_info, skill):
CommonSimSkillUtils.remove_skill(sim_info, skill)
else:
CommonSimSkillUtils.set_current_skill_level(sim_info, skill, int(chosen_skill_level))
CommonBasicNotification(
S4CMSimModifySkillsStringId.RANDOMIZED_SKILL_LEVELS_OF_SIM_TITLE,
S4CMSimModifySkillsStringId.RANDOMIZED_SKILL_LEVELS_OF_SIM_DESCRIPTION,
title_tokens=(sim,),
description_tokens=(sim,)
).show(icon=IconInfoData(obj_instance=sim))
_on_close()
def get_definition_notebook_data(self, ingredient_cache=[]):
ingredients_used = {}
recipe_definition = self.get_recipe_definition()
if recipe_definition is None or self.final_product is None:
return
ingredient_display = []
if recipe_definition.use_ingredients is not None:
for tuned_ingredient_factory in recipe_definition.sorted_ingredient_requirements:
ingredients_found_count = 0
ingredients_needed_count = 0
ingredient_requirement = tuned_ingredient_factory()
ingredient_requirement.attempt_satisfy_ingredients(
ingredient_cache, ingredients_used)
ingredients_found_count += ingredient_requirement.count_satisfied
ingredients_needed_count += ingredient_requirement.count_required
ingredient_display.append(
SubListData(None, ingredients_found_count,
ingredients_needed_count, True, False,
ingredient_requirement.get_diplay_name(), None,
None))
return EntryData(
LocalizationHelperTuning.get_object_name(self.final_product),
IconInfoData(obj_def_id=self.final_product.id),
self._get_entry_tooltip(self.final_product), ingredient_display,
self.entry_sublist_is_sortable)
def build_gig_msg(cls, msg, sim, gig_time=None, gig_customer=None):
msg.gig_type = cls.guid64
msg.gig_name = cls.display_name(sim)
(pay_lower, pay_upper) = cls._get_base_pay_for_gig_owner(sim)
msg.min_pay = pay_lower
msg.max_pay = pay_upper
msg.gig_icon = ResourceKey()
msg.gig_icon.instance = cls.display_icon.instance
msg.gig_icon.group = cls.display_icon.group
msg.gig_icon.type = cls.display_icon.type
if cls.odd_job_tuning is not None and cls.odd_job_tuning.use_customer_description_as_gig_description and gig_customer is not None:
customer_sim_info = services.sim_info_manager().get(gig_customer)
if customer_sim_info is not None:
msg.gig_description = cls.odd_job_tuning.customer_description(
customer_sim_info)
else:
msg.gig_description = cls.display_description(sim)
if gig_time is not None:
msg.gig_time = gig_time
if gig_customer is not None:
msg.customer_id = gig_customer
if cls.tip is not None:
msg.tip_title = cls.tip.tip_title()
if cls.tip.tip_icon is not None or cls.tip.tip_text is not None:
build_icon_info_msg(
IconInfoData(icon_resource=cls.tip.tip_icon),
None,
msg.tip_icon,
desc=cls.tip.tip_text())
def create_routing_info(cls):
routing_info = InteractionInfo(
interactions.base.interaction.ROUTING_POSTURE_INTERACTION_ID, None,
(), False, True, cls.ROUTING_DATA.routing_name,
IconInfoData(icon_resource=cls.ROUTING_DATA.icon), None, None,
Sims_pb2.Interaction.POSTURE, Sims_pb2.IQ_RUNNING, None, 0,
interactions.priority.Priority.High, None)
return routing_info
def factory(resolver,
participant_type,
balloon_target_override=None,
**kwargs):
if resolver is None:
logger.callstack('Attempting to use a None resolver in an icon.',
level=LEVEL_ERROR,
owner='rmccord')
return EMPTY_ICON_INFO_DATA
if balloon_target_override is not None:
return IconInfoData(obj_instance=balloon_target_override)
icon_targets = resolver.get_participants(participant_type)
if icon_targets:
chosen_object = random.choice(icon_targets)
else:
chosen_object = None
return IconInfoData(obj_instance=chosen_object)
def show_employee_management_dialog(opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
return False
business_services = services.business_service()
business_manager = business_services.get_business_manager_for_zone()
if business_manager is None:
return False
business_tracker = business_services.get_business_tracker_for_household(
sim_info.household_id, business_manager.business_type)
msg = Business_pb2.ManageEmployeesDialog()
msg.hiring_sim_id = sim_info.sim_id
def get_sim_filter_gsi_name():
return 'Business Command: Get New Possible Employees'
for (business_employee_type, business_employee_data
) in business_manager.tuning_data.employee_data_map.items():
with ProtocolBufferRollback(msg.jobs) as employee_job_msg:
total_unlocked_slots = business_employee_data.employee_count_default + business_tracker.get_additional_employee_slots(
business_employee_type)
employee_job_msg.open_slots = total_unlocked_slots - business_manager.get_employee_count(
business_employee_type)
employee_job_msg.locked_slots = business_employee_data.employee_count_max - total_unlocked_slots
employee_job_msg.job_type = int(business_employee_type)
employee_job_msg.job_name = business_employee_data.job_name
employee_job_msg.job_icon = create_icon_info_msg(
IconInfoData(business_employee_data.job_icon))
current_employees = business_manager.get_employees_by_type(
business_employee_type)
sim_info_manager = services.sim_info_manager()
for employee_sim_id in current_employees:
employee_sim_info = sim_info_manager.get(employee_sim_id)
with ProtocolBufferRollback(
employee_job_msg.employees) as employee_msg:
business_manager.populate_employee_msg(
employee_sim_info, employee_msg,
business_employee_type, business_employee_data)
results = services.sim_filter_service().submit_matching_filter(
number_of_sims_to_find=business_employee_data.
potential_employee_pool_size,
sim_filter=business_employee_data.
potential_employee_pool_filter,
requesting_sim_info=sim_info,
allow_yielding=False,
gsi_source_fn=get_sim_filter_gsi_name)
for result in results:
with ProtocolBufferRollback(
employee_job_msg.available_sims) as employee_msg:
business_manager.populate_employee_msg(
result.sim_info, employee_msg, business_employee_type,
business_employee_data)
op = shared_messages.create_message_op(
msg, Consts_pb2.MSG_MANAGE_EMPLOYEES_DIALOG)
Distributor.instance().add_op_with_no_owner(op)
def create_calendar_entry(self):
calendar_entry = super().create_calendar_entry()
situation_type = self._situation_seed.situation_type
calendar_entry.zone_id = self._situation_seed.zone_id
build_icon_info_msg(
IconInfoData(icon_resource=situation_type.calendar_icon),
situation_type.display_name, calendar_entry.icon_info)
calendar_entry.scoring_enabled = self._situation_seed.scoring_enabled
return calendar_entry
def handle_event(self, sim_info, event, resolver):
super().handle_event(sim_info, event, resolver)
if event == TestEvent.SimActiveLotStatusChanged and not self._tns_popped:
sim = sim_info.get_sim_instance()
if sim is not None and (
sim.is_on_active_lot()
and self.is_sim_in_situation(sim)) and self.sim_has_job(
sim, self.neighbor_job_and_default_role_state.job):
active_sim = services.get_active_sim()
if active_sim is not None:
dialog = self._arrival_notification(active_sim)
dialog.show_dialog(
icon_override=IconInfoData(obj_instance=sim),
secondary_icon_override=IconInfoData(
obj_instance=active_sim))
self._tns_popped = True
services.get_event_manager().unregister_single_event(
self, TestEvent.SimActiveLotStatusChanged)
def build_msg(self, **kwargs):
msg = super().build_msg(**kwargs)
msg.dialog_type = Dialog_pb2.UiDialogMessage.ICONS_LABELS
sim_info = self.owner.sim_info
if sim_info is None:
logger.error('Sim Info was None for {}', self._target_sim_id)
return msg
progress_description = self.progress_description
aspiration_tracker = sim_info.aspiration_tracker
if progress_description is not None:
complete_loc_string = progress_description.complete(sim_info)
for aspiration in self.aspirations:
icon_resource = None
if aspiration.display_icon is not None:
icon_resource = aspiration.display_icon
name = None
if aspiration.display_name is not None:
name = aspiration.display_name(sim_info)
desc = None
if progress_description is not None:
aspiration_completed = aspiration_tracker.milestone_completed(
aspiration)
num_objectives = len(aspiration.objectives)
if num_objectives == 0:
logger.error('Aspiration {} has no objectives.',
aspiration)
num_progress = 0
num_goal = 0
if num_objectives == 1:
num_progress = aspiration_tracker.get_objective_count(
aspiration.objectives[0])
num_goal = aspiration.objectives[0].goal_value()
else:
num_progress = sum(
aspiration_tracker.objective_completed(objective)
for objective in aspiration.objectives)
num_goal = aspiration.objective_completion_count()
if aspiration_completed:
desc = complete_loc_string
else:
desc = progress_description.incomplete(
sim_info, num_progress, num_goal)
elif aspiration.display_description is not None:
desc = aspiration.display_description(sim_info)
tooltip = None
if not self.use_description_for_tooltip and aspiration.display_tooltip is not None:
tooltip = aspiration.display_tooltip(sim_info)
elif self.use_description_for_tooltip:
if aspiration.display_description is not None:
tooltip = aspiration.display_description(sim_info)
icon_data = IconInfoData(icon_resource=icon_resource)
msg.icon_infos.append(
create_icon_info_msg(icon_data,
name=name,
desc=desc,
tooltip=tooltip))
return msg
def _show_re_rank_up_notifications(self, sim_info, current_rank, rank_data,
rank_up_data, icon_override):
if rank_up_data.re_rank_up_notification is not None:
notification = rank_up_data.re_rank_up_notification(
sim_info, resolver=SingleSimResolver(sim_info))
notification.show_dialog(
icon_override=icon_override,
secondary_icon_override=IconInfoData(obj_instance=sim_info),
additional_tokens=(current_rank, ))
def create_calendar_entry(self):
calendar_entry = super().create_calendar_entry()
calendar_entry.zone_id = self._zone_id
build_icon_info_msg(
IconInfoData(
icon_resource=self._display_data.instance_display_icon),
self._display_data.instance_display_name, calendar_entry.icon_info)
calendar_entry.scoring_enabled = False
return calendar_entry
def _handle_scolding_interaction(self, sim_info, event, resolver):
target = resolver.interaction.target
if resolver.interaction.sim.sim_info is not sim_info:
return
if not self.owner.is_sim_in_situation(target):
return
self._scold_count += 1
if self.inappropriate_behavior_threshold.compare(self._scold_count):
dialog = self.scolding_notification(sim_info)
dialog.show_dialog(secondary_icon_override=IconInfoData(obj_instance=sim_info))
else:
dialog = self.send_away_notification(sim_info)
dialog.show_dialog(secondary_icon_override=IconInfoData(obj_instance=sim_info))
sim = sim_info.get_sim_instance()
context = InteractionContext(sim, InteractionContext.SOURCE_SCRIPT, Priority.Critical)
execute_result = sim.push_super_affordance(self.send_away_inappropriate_sim_interaction, target, context)
if execute_result:
execute_result.interaction.register_on_finishing_callback(self._sent_away_finished_callback)
