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)