def show_dialog(self, **kwargs): self.title = lambda **_: LocalizationHelperTuning.get_raw_text( 'Tuning Error Notifier') self.text = lambda **_: LocalizationHelperTuning.get_raw_text( 'XML tuning errors matching your filters were detected. Press OK to view these in your web browser, or Cancel to ignore.' ) super().show_dialog(**kwargs)
def get_test_result(self, sim, cls): unavailable_items = Counter() unavailable_item_description = {} for item in self.ingredients: item_count = sim.inventory_component.get_item_quantity_by_definition( item.ingredient) if item_count < item.quantity: unavailable_items[ item.ingredient] += item.quantity - item_count unavailable_item_description[ item.ingredient] = item.missing_ingredient_additional_text if unavailable_items: tooltip = LocalizationHelperTuning.get_bulleted_list( ItemCost.UNAVAILABLE_TOOLTIP_HEADER(sim), *tuple( LocalizationHelperTuning.get_object_count( count, ingredientDef, detail_text=unavailable_item_description[ingredientDef] ) for (ingredientDef, count) in unavailable_items.items())) return event_testing.results.TestResult( False, "Sim doesn't have the required items in inventory.", tooltip=lambda *_, **__: tooltip) return TestResult.TRUE
def show_royalty_notification(self, royalty_payment_dict): notification_text = LocalizationHelperTuning.get_new_line_separated_strings(*(LocalizationHelperTuning.get_bulleted_list(RoyaltyTracker.get_name_for_type(royalty_type), *(RoyaltyTracker.get_line_item_string(r.entry_name, royalty_payment_dict[r]) for r in royalty_list)) for (royalty_type, royalty_list) in self._royalties.items())) notification_text = LocalizationHelperTuning.get_new_line_separated_strings(self.ROYALTY_NOTIFICATION_HEADER, notification_text) sim_info = self.sim_info resolver = SingleSimResolver(sim_info) dialog = self.ROYALTY_NOTIFICATION(sim_info, resolver, text=lambda *_: notification_text) dialog.show_dialog()
def _ui_metadata_gen(self): if GardeningTuning.is_spliced(self.owner): fruit_names = self.get_root_stock_names() description = LocalizationHelperTuning.get_comma_separated_list( *fruit_names) plant_name = GardeningTuning.SPLICED_PLANT_NAME() else: unidentified_overrides = self._unidentified_overrides if unidentified_overrides is not None and GardeningTuning.is_unidentified( self.owner): description = unidentified_overrides.unidentified_description plant_name = unidentified_overrides.unidentified_name else: if self.is_shoot and self.root_stock is not None: description = LocalizationHelperTuning.get_name_value_pair( GardeningTuning.SHOOT_DESCRIPTION_STRING, LocalizationHelperTuning.get_object_name( self.root_stock.main_spawner.definition)) else: description = LocalizationHelperTuning.get_object_description( self.owner.definition) plant_name = LocalizationHelperTuning.get_object_name( self.owner.definition) yield ('recipe_name', plant_name) yield ('recipe_description', description) subtext = self.owner.get_state_strings() if subtext is not None: yield ('subtext', subtext)
def get_state_strings(self, first_string=None): obj = self.owner int_token = 0 for state_int_data in self.state_value_numbers: state_value = state_int_data.state_value if state_value is None: continue if obj.has_state(state_value.state): if obj.get_state(state_value.state) is state_value: int_token = state_int_data.number break bullet_points = [] if first_string is None else [first_string] for state_string_datas in self.state_value_strings: for state_string_data in state_string_datas: state_value = state_string_data.state_value if state_value is None: continue if obj.has_state(state_value.state) and obj.get_state( state_value.state) is state_value: bullet_point = state_string_data.text(int_token) bullet_points.append(bullet_point) break if bullet_points: if len(bullet_points) == 1: return LocalizationHelperTuning.get_raw_text(bullet_points[0]) else: return LocalizationHelperTuning.get_bulleted_list( None, *bullet_points)
def get_interaction_tooltip(self, tooltip=None, sim=None): if self.ingredients: item_tooltip = LocalizationHelperTuning.get_bulleted_list(self.AVAILABLE_TOOLTIP_HEADER(sim), *tuple(LocalizationHelperTuning.get_object_count(ingredient.quantity, ingredient.ingredient) for ingredient in self.ingredients)) if tooltip is None: return item_tooltip return LocalizationHelperTuning.get_new_line_separated_strings(tooltip, item_tooltip) return tooltip
def _get_name(cls, inst, target=DEFAULT, context=DEFAULT, track=None, **interaction_parameters): if track is None: return inst.create_localized_string(inst.display_name) tag_set = None if track in ObjectRelationshipTrack.OBJECT_BASED_FRIENDSHIP_TRACKS: tag_set = ObjectRelationshipTrack.OBJECT_BASED_FRIENDSHIP_TRACKS[ track] if tag_set is not None: relationship_service = services.relationship_service() relationship = relationship_service.get_object_relationship( context.sim.id, tag_set) if relationship is not None: object_name = relationship.get_object_rel_name() if object_name: if cls.custom_name_string_wrapper is not None: return cls.custom_name_string_wrapper( LocalizationHelperTuning.get_raw_text(object_name)) return LocalizationHelperTuning.get_raw_text(object_name) if track in cls.object_variant_mapping: return cls.create_localized_string( cls.object_variant_mapping[track].display_name, context=context, target=target) return inst.create_localized_string(inst.display_name)
def _apply_to_subject_and_target(self, subject, target, resolver): if subject.is_npc: return obj_counter = Counter() if self._object_rewards.spawn_type == ObjectRewardsTuning.SPAWNER_REWARD: participant = resolver.get_participant( self._object_rewards.spawner_participant) if participant is not None: weighted_data = participant.interaction_spawner_data() if weighted_data is not None: self._create_object_rewards(weighted_data, obj_counter, resolver) elif self._object_rewards.spawn_type == ObjectRewardsTuning.TUNABLE_REWARD: for _ in range(self._object_rewards.quantity): weight_pairs = [(data.weight, data.reward) for data in self._object_rewards.reward_objects ] self._create_object_rewards(weight_pairs, obj_counter, resolver) if obj_counter and self._notification is not None: obj_names = [ LocalizationHelperTuning.get_object_count(count, obj) for (obj, count) in obj_counter.items() ] dialog = self._notification(subject, resolver=resolver) dialog.show_dialog( additional_tokens=(LocalizationHelperTuning.get_bulleted_list( None, *obj_names), )) return True
def register_custom_career(opt_sim: OptionalSimInfoParam = None, _connection=None): sim_info = get_optional_target(opt_sim, target_type=OptionalSimInfoParam, _connection=_connection) def on_response(dialog): if not dialog.accepted: return name = dialog.text_input_responses.get(Career.TEXT_INPUT_NEW_NAME) description = dialog.text_input_responses.get( Career.TEXT_INPUT_NEW_DESCRIPTION) sim_info.career_tracker.set_custom_career_data( custom_name=name, custom_description=description) register_dialog_data = Career.REGISTER_CAREER_DIALOG_DATA dialog = register_dialog_data.register_career_dialog( sim_info, SingleSimResolver(sim_info)) text_input_overrides = None if sim_info.career_tracker.has_custom_career: text_input_overrides = {} custom_career_data = sim_info.career_tracker.custom_career_data text_input_overrides[ Career. TEXT_INPUT_NEW_NAME] = lambda *_, **__: LocalizationHelperTuning.get_raw_text( custom_career_data.get_custom_career_name()) text_input_overrides[ Career. TEXT_INPUT_NEW_DESCRIPTION] = lambda *_, **__: LocalizationHelperTuning.get_raw_text( custom_career_data.get_custom_career_description()) dialog.show_dialog(on_response=on_response, text_input_overrides=text_input_overrides) return True
def _do_behavior(self): royalty_payment = self.royalty_payment recipient = self.interaction.get_participant( royalty_payment.royalty_recipient) if recipient is None: logger.error( "Trying to set up a royalty payment but interaction, {}, doesn't have the participant type {}.", self.interaction, royalty_payment.royalty_recipient) royalty_tracker = recipient.sim_info.royalty_tracker if royalty_tracker is None: logger.error( 'Trying to set up a royalty payment but the sim has a None royalty tracker.' ) participant = self.interaction.get_participant( royalty_payment.royalty_subject) if participant is None: logger.error( "Trying to set up a royalty payment but the royalty subject, {}, doesn't exist in this interaction.", royalty_payment.royalty_subject) if isinstance(participant, (str, LocalizedString)): display_name = LocalizationHelperTuning.get_raw_text(participant) else: display_name = LocalizationHelperTuning.get_object_name( participant) royalty_tracker.start_royalty( royalty_payment.royalty_type, royalty_payment.guid64, display_name, royalty_payment.payment_multipliers.get_multiplier( self.interaction.get_resolver()))
def name(self): if self._pet_familiar_id is None: return LocalizationHelperTuning.get_raw_text(self._name) pet_familiar = services.sim_info_manager().get(self._pet_familiar_id) if pet_familiar is None: logger.error("Attempting to get the name of a pet familiar that doesn't exist.") return return LocalizationHelperTuning.get_sim_name(pet_familiar)
def _get_entry_tooltip(self, entry_def): return EntryTooltip( HovertipStyle.HOVER_TIP_DEFAULT, { TooltipFields.recipe_name: LocalizationHelperTuning.get_object_name(entry_def), TooltipFields.recipe_description: LocalizationHelperTuning.get_object_description(entry_def) })
def show_notif(sim, text): title = "{} said".format( Distributor.instance().get_distributor_with_active_sim_matching_sim_id( sim.id).client._account.persona_name) notification = UiDialogNotification.TunableFactory().default( sim, text=lambda **_: LocalizationHelperTuning.get_raw_text(text), title=lambda **_: LocalizationHelperTuning.get_raw_text(title)) notification.show_dialog(icon_override=(None, sim))
def get_non_active_display(cls, token_data): if token_data.token_property == GlobalPolicyTokenType.NAME: return LocalizationHelperTuning.get_raw_text( token_data.global_policy.display_name()) if token_data.token_property == GlobalPolicyTokenType.PROGRESS: return LocalizationHelperTuning.get_raw_text( cls.GLOBAL_POLICY_TOKEN_NON_ACTIVE()) logger.error( 'Invalid Global Policy Property {} tuned on the Global Policy token.' .format(token_data.property))
def update_hovertip(cls, owner, crafter=None): description = cls.recipe_description(crafter) genre = Genre.get_genre_localized_string(owner) if genre is not None: description = LocalizationHelperTuning.get_new_line_separated_strings(description, genre) value_text = cls.value_text if value_text: localized_value = value_text(owner.current_value) description = LocalizationHelperTuning.get_new_line_separated_strings(description, localized_value) objects.components.crafting_component._set_recipe_decription(owner, description)
def name(self): if self._name is not None: if self._localized_custom_name is None: self._localized_custom_name = LocalizationHelperTuning.get_raw_text( self._name) if self._localized_custom_name is not None: return self._localized_custom_name if self.club_seed is not None: return self.club_seed.name return LocalizationHelperTuning.get_raw_text('')
def get_tooltip_field(self, field, context=None, target=None): if field == TooltipFields.relic_description: sim = context.sim if sim is None: return return sim.sim_info.relic_tracker.get_description_for_objects( self.owner, target) name = TooltipFieldsComplete(field).name existing_handle = self._ui_metadata_handles.get(name, None) if existing_handle is not None: (_, _, value) = self.owner.get_ui_metadata(existing_handle) return value tooltip_component = None tooltip_override = self.owner.get_tooltip_override() if tooltip_override is not None: tooltip_component = tooltip_override.get_component( types.TOOLTIP_COMPONENT) if tooltip_component is None: tooltip_component = self tooltip_text = None resolver = SingleObjectResolver(self.owner) for tooltip_data in tooltip_component.custom_tooltips: object_tests = tooltip_data.object_tests if object_tests and not object_tests.run_tests(resolver): continue tooltip_text = tooltip_data.tooltip_fields.get(field, tooltip_text) if tooltip_text is not None: if tooltip_text.text_tokens is not None: tokens = tooltip_text.text_tokens.get_tokens(resolver) if None in tokens: return else: tokens = () text = tooltip_text.text(*tokens) external_field_data_tuple = tooltip_component._external_field_to_data.get( name) if external_field_data_tuple: tooltip_override_data = tooltip_text.override_component_information if tooltip_override_data is not None: if tooltip_override_data.concatenation_type == TooltipFieldConcatenationType.CONCATENATE_BEFORE: text = LocalizationHelperTuning.get_separated_string_by_style( tooltip_override_data.concatenation_style, text, external_field_data_tuple.field_data) else: text = LocalizationHelperTuning.get_separated_string_by_style( tooltip_override_data.concatenation_style, external_field_data_tuple.field_data, text) if name == self.SUBTEXT_HANDLE: if tooltip_component._ui_metadata_handles: subtext = tooltip_component.get_state_strings(text) if subtext is not None: text = subtext handle = self.owner.add_ui_metadata(name, text) self._ui_metadata_handles[name] = handle return text
def _payout_rebates(self, *_): if not self._rebates: return active_sim = self._household.client.active_sim line_item_text = LocalizationHelperTuning.get_new_line_separated_strings(*(self.REBATE_NOTIFICATION_LINE_ITEM(t.display_name(active_sim), a) for (t, a) in self._rebates.items())) notification_text = LocalizationHelperTuning.get_new_line_separated_strings(self.REBATE_NOTIFICATION_HEADER, line_item_text) dialog = self.REBATE_NOTIFICATION(active_sim, text=lambda *_, **__: notification_text) dialog.show_dialog() total_rebate_amount = sum(self._rebates.values()) self._household.funds.add(total_rebate_amount, reason=Consts_pb2.TELEMETRY_MONEY_ASPIRATION_REWARD, sim=active_sim) self.clear_rebates()
def show_notification(text, title=None): client = services.client_manager().get_first_client() if title is None: title = 'Neutron Core' localized_title = lambda **_: LocalizationHelperTuning.get_raw_text(title) localized_text = lambda **_: LocalizationHelperTuning.get_raw_text(text) notification = UiDialogNotification.TunableFactory().default( client.active_sim, text=localized_text, title=localized_title) notification.show_dialog()
def mp_chat(target_id=None, _connection=None): try: target_id = int(target_id) ts4mp_log("chat", target_id) distributor = Distributor.instance( ).get_distributor_with_active_sim_matching_sim_id(target_id) client = distributor.client ts4mp_log("chat", client) def enter_dialog_callback(dialog): if not dialog.accepted: ts4mp_log("chat", "Dialog was not accepted.") return dialog_text = dialog.text_input_responses.get("dialog") ts4mp_log("chat", 'Showing message') distributor = Distributor.instance( ).get_distributor_with_active_sim_matching_sim_id(target_id) if distributor is not None: client = distributor.client ts4mp_log("chat", 'Showing message') show_notif(client.active_sim, dialog_text) localized_title = lambda **_: LocalizationHelperTuning.get_raw_text( "Say Something") localized_text = lambda **_: LocalizationHelperTuning.get_raw_text( "Say something to anybody who's listening.") localized_fname = lambda **_: LocalizationHelperTuning.get_raw_text( "Type your message here!") localized_lname = lambda **_: LocalizationHelperTuning.get_raw_text( "Type your emote here!") text_input_1 = UiTextInput(sort_order=0) text_input_1.default_text = localized_fname text_input_1.title = None text_input_1.max_length = 100 text_input_1.initial_value = localized_fname text_input_1.length_restriction = Scum_TextInputLengthName() inputs = AttributeDict({'dialog': text_input_1}) dialog = UiDialogTextInputOkCancel.TunableFactory().default( client.active_sim, text=localized_text, title=localized_title, text_inputs=inputs, is_special_dialog=True) ts4mp_log("chat", "Dialog id: {}".format(dialog.dialog_id)) dialog.add_listener(enter_dialog_callback) dialog.show_dialog() except Exception as e: ts4mp_log('chat', e)
def get_definition_notebook_data(self, ingredient_cache=()): definition_manager = services.definition_manager() fruit_definition = definition_manager.get( self.entry_object_definition_id) if fruit_definition is None: return gardening_tuned_values = fruit_definition.cls._components.gardening._tuned_values plant_definition = gardening_tuned_values.plant sub_list_data = [] sub_list_data.append( SubListData(None, 0, 0, True, False, self.entry_text_value(fruit_definition.price / 5), None, None)) season_service = services.season_service() if season_service is not None: season_text = GardeningTuning.get_seasonality_text_from_plant( plant_definition) if season_text is None: season_text = GardeningTuning.PLANT_SEASONALITY_TEXT( GardeningTuning.SEASONALITY_ALL_SEASONS_TEXT) sub_list_data.append( SubListData(None, 0, 0, True, False, season_text, None, None)) sub_list_data.append( SubListData( None, 0, 0, True, False, LocalizationHelperTuning.get_object_description( plant_definition), None, None)) for (splice_fruit, splice_fruit_result ) in gardening_tuned_values.splicing_recipies.items(): sub_list_data.append( SubListData( None, 0, 0, True, False, self.entry_text_splicing(splice_fruit, splice_fruit_result), None, None)) gardening_collection_data = ObjectCollectionData.get_collection_data( CollectionIdentifier.Gardening) for obj_data in itertools.chain( gardening_collection_data.object_list, gardening_collection_data.bonus_object_list): if obj_data.collectable_item is fruit_definition: rarity_text = ObjectCollectionData.COLLECTION_RARITY_MAPPING[ obj_data.rarity].text_value sub_list_data.append( SubListData(None, 0, 0, True, False, self.entry_text_rarity(rarity_text), None, None)) break entry_data = EntryData( LocalizationHelperTuning.get_object_name(fruit_definition), IconInfoData(obj_def_id=fruit_definition.id), None, sub_list_data, None) return entry_data
def update_hovertip(cls, owner, crafter=None): description = cls.recipe_description(crafter) genre = Genre.get_genre_localized_string(owner) if genre is not None: description = LocalizationHelperTuning.get_new_line_separated_strings( description, genre) value_text = cls.value_text if value_text: localized_value = value_text(owner.current_value) description = LocalizationHelperTuning.get_new_line_separated_strings( description, localized_value) objects.components.crafting_component._set_recipe_decription( owner, description)
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 _get_fish_caught_text(self, fish_caught): all_fish_strings = [] for fish in fish_caught: type_loc_string = LocalizationHelperTuning.get_object_name( fish.definition) value_loc_string = LocalizationHelperTuning.get_money( fish.current_value) weight_loc_string = fish.get_localized_weight() fish_data_text = self.fish_information_text( weight_loc_string, type_loc_string, value_loc_string) all_fish_strings.append(fish_data_text) final_fish_text = LocalizationHelperTuning.get_bulleted_list( self.fish_header_text(), *all_fish_strings) return final_fish_text
def _apply_to_subject_and_target (self, subject, target, resolver, placement_override_func = None, post_object_create_func = None): if subject.is_npc: return obj_counter = Counter() quantity = self._object_rewards.quantity quantity += self._object_rewards.tested_bonus_quantity.get_modified_value(resolver) for _ in range(int(quantity)): weight_pairs = [(data.weight, (data.reward, data.states_on_reward_object, data.quantity)) for data in self._object_rewards.reward_objects] self._create_object_rewards(weight_pairs, obj_counter, resolver, subject = subject, placement_override_func = placement_override_func, post_object_create_func = post_object_create_func) if obj_counter and self._notification is not None: obj_names = [LocalizationHelperTuning.get_object_count(count, obj) for (obj, count) in obj_counter.items()] dialog = self._notification(subject, resolver = resolver) dialog.show_dialog(additional_tokens = (LocalizationHelperTuning.get_bulleted_list(None, *obj_names),)) return True
def get_active_policy_display(self, token_data): if token_data.token_property == GlobalPolicyTokenType.NAME: return LocalizationHelperTuning.get_raw_text(self.display_name()) if token_data.token_property == GlobalPolicyTokenType.PROGRESS: progress_percentage_str = str( int( round( float(self.progress_value) / float(self.progress_max_value), 2) * 100)) return LocalizationHelperTuning.get_raw_text( progress_percentage_str) logger.error( 'Invalid Global Policy Property {} tuned on the Global Policy token.' .format(token_data.property))
def show_royalty_notification(self, royalty_payment_dict): notification_text = LocalizationHelperTuning.get_new_line_separated_strings( *(LocalizationHelperTuning.get_bulleted_list( RoyaltyTracker.get_name_for_type(royalty_type), *(RoyaltyTracker.get_line_item_string(r.entry_name, royalty_payment_dict[r]) for r in royalty_list)) for (royalty_type, royalty_list) in self._royalties.items() if royalty_list)) sim_info = self.sim_info resolver = SingleSimResolver(sim_info) dialog = self.ROYALTY_NOTIFICATION(sim_info, resolver, text=lambda *_: notification_text) dialog.show_dialog()
def _do_behavior(self): royalty_payment = self.royalty_payment recipient = self.interaction.get_participant(royalty_payment.royalty_recipient) if recipient is None: logger.error("Trying to set up a royalty payment but interaction, {}, doesn't have the participant type {}.", self.interaction, royalty_payment.royalty_recipient) royalty_tracker = recipient.sim_info.royalty_tracker if royalty_tracker is None: logger.error('Trying to set up a royalty payment but the sim has a None royalty tracker.') participant = self.interaction.get_participant(royalty_payment.royalty_subject) if participant is None: logger.error("Trying to set up a royalty payment but the royalty subject, {}, doesn't exist in this interaction.", royalty_payment.royalty_subject) if isinstance(participant, (str, LocalizedString)): display_name = LocalizationHelperTuning.get_raw_text(participant) else: display_name = LocalizationHelperTuning.get_object_name(participant) royalty_tracker.start_royalty(royalty_payment.royalty_type, royalty_payment.guid64, display_name, royalty_payment.payment_multipliers.get_multiplier(self.interaction.get_resolver()))
def _run_interaction_gen(self, timeline): target_name_component = self.target.name_component def on_response(dialog): if not dialog.accepted: return name = dialog.text_input_responses.get(self.TEXT_INPUT_NEW_NAME) description = dialog.text_input_responses.get(self.TEXT_INPUT_NEW_DESCRIPTION) target = self.target if target is not None: if name is not None: target.set_custom_name(name) if description is not None: target.set_custom_description(description) self._update_ui_metadata(target) sequence = self._build_outcome_sequence() services.time_service().sim_timeline.schedule(element_utils.build_element(sequence)) text_input_overrides = {} (template_name, template_description) = target_name_component.get_template_name_and_description() if target_name_component.allow_name: text_input_overrides[self.TEXT_INPUT_NEW_NAME] = None if self.target.has_custom_name(): text_input_overrides[self.TEXT_INPUT_NEW_NAME] = lambda *_, **__: LocalizationHelperTuning.get_object_name(self.target) elif template_name is not None: text_input_overrides[self.TEXT_INPUT_NEW_NAME] = template_name if target_name_component.allow_description: text_input_overrides[self.TEXT_INPUT_NEW_DESCRIPTION] = None if self.target.has_custom_description(): text_input_overrides[self.TEXT_INPUT_NEW_DESCRIPTION] = lambda *_, **__: LocalizationHelperTuning.get_object_description(self.target) elif template_description is not None: text_input_overrides[self.TEXT_INPUT_NEW_DESCRIPTION] = template_description dialog = self.rename_dialog(self.sim, self.get_resolver()) dialog.show_dialog(on_response=on_response, text_input_overrides=text_input_overrides) return True
def _add_consumable_hovertip(self): owner = self.owner owner.hover_tip = ui_protocols.UiObjectMetadata.HOVER_TIP_CONSUMABLE_CRAFTABLE crafting_process = self._crafting_process recipe = self._get_recipe() if recipe is None: return self.owner.update_tooltip_field( TooltipFieldsComplete.recipe_name, recipe.get_recipe_name(crafting_process.crafter)) crafted_by_text = crafting_process.get_crafted_by_text( is_from_gallery=self.owner.is_from_gallery) crafted_with_text = crafting_process.get_crafted_with_text() if crafted_by_text is not None: if crafted_with_text is not None: crafted_by_text = LocalizationHelperTuning.NEW_LINE_LIST_STRUCTURE( crafted_by_text, crafted_with_text) crafter_sim_id = crafting_process.crafter_sim_id if crafter_sim_id is not None: self.owner.update_tooltip_field( TooltipFieldsComplete.crafter_sim_id, crafter_sim_id) elif crafted_with_text is not None: crafted_by_text = crafted_with_text self.owner.update_tooltip_field(TooltipFieldsComplete.crafted_by_text, crafted_by_text) if owner.has_state(CraftingTuning.QUALITY_STATE): value_quality = CraftingTuning.QUALITY_STATE_VALUE_MAP.get( owner.get_state(CraftingTuning.QUALITY_STATE)) if value_quality is not None: self.owner.update_tooltip_field( TooltipFieldsComplete.quality, value_quality.state_star_number) if owner.has_state( CraftingTuning.MASTERWORK_STATE ) and owner.get_state( CraftingTuning.MASTERWORK_STATE ) is CraftingTuning.MASTERWORK_STATE_VALUE and recipe.masterwork_name is not None: self.owner.update_tooltip_field( TooltipFieldsComplete.quality_description, recipe.masterwork_name) inscription = crafting_process.inscription if inscription is not None: self.owner.update_tooltip_field(TooltipFieldsComplete.inscription, inscription) self._add_spoil_listener( state_override=recipe.spoil_time_commodity_override) if recipe.time_until_spoiled_string_override is not None: self.owner.update_tooltip_field( TooltipFieldsComplete.spoiled_time_text, recipe.time_until_spoiled_string_override) subtext = self.owner.get_state_strings() if subtext is not None: self.owner.update_tooltip_field(TooltipFieldsComplete.subtext, subtext) recipe.update_hovertip(self.owner, crafter=crafting_process.crafter) current_inventory = owner.get_inventory() if current_inventory is not None: current_inventory.push_inventory_item_update_msg(owner) self.owner.on_hovertip_requested() self.owner.update_object_tooltip()
def get_string(self, sim_info): degree_tracker = sim_info.degree_tracker if degree_tracker is None: logger.error( 'Trying to perform UniversityDynamicSignView op on sim {} with no degree tracker.', sim_info) return uni = self.university manager = services.get_instance_manager( sims4.resources.Types.UNIVERSITY_MAJOR) degree_ids = degree_tracker.get_available_degrees_to_enroll()[ uni.guid64] bullet_points = () if self.info_type == UniversityInfoType.PRESTIGE_DEGREES: bullet_points = (manager.get(i).display_name for i in degree_ids if i in uni.prestige_degree_ids) elif self.info_type == UniversityInfoType.NON_PRESTIGE_DEGREES: bullet_points = (manager.get(i).display_name for i in degree_ids if i in uni.non_prestige_degree_ids) final_string = LocalizationHelperTuning.get_bulleted_list( None, *bullet_points) if final_string is None: final_string = self.fallback_string(sim_info) return final_string
def _get_cost_string(cls, inst, entry): cost_string = entry.cost_string if cost_string is None: return if isinstance(cost_string, int): return LocalizationHelperTuning.get_for_money(cost_string) return cost_string()
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 add_aop(self, aop, user_pick_target=None, result_override=DEFAULT, do_test=True): result = ChoiceMenu.is_valid_aop(aop, self.context, self.make_pass, user_pick_target=user_pick_target, result_override=result_override, do_test=do_test) if aop.affordance.allow_user_directed is False: if _show_interaction_failure_reason: if result: failure_result = TestResult( False, tooltip=lambda *_, **__: LocalizationHelperTuning.get_name_value_pair( 'Failure', 'Not allowed user-directed')) else: failure_result = result self._add_menu_item(aop, failure_result) return result if not result and not result.tooltip: return result self._add_menu_item(aop, result) return result
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 set_custom_name(self, name): if self.allow_name: self.owner.custom_name = name if name else None self._call_name_changed_callback() if self.owner.update_object_tooltip() is None and isinstance(self.owner, ClientObjectMixin): _set_recipe_name(self.owner, LocalizationHelperTuning.get_raw_text(name)) return True return False
def set_custom_description(self, description): if self.allow_description: self.owner.custom_description = description if description else None self._call_name_changed_callback() if self.owner.update_object_tooltip() is None and isinstance(self.owner, ClientObjectMixin): _set_recipe_decription(self.owner, LocalizationHelperTuning.get_raw_text(description)) return True return False
def get_genre_localized_string(obj): genres = Genre.get_genres(obj) if not genres: return strings = tuple(Genre.TAG_TO_TUNING_MAP[genre].localized_name for genre in genres) comma_seperated_list = LocalizationHelperTuning.get_comma_separated_list(*strings) genre_text = Genre.GENRE_PREFIX_STRING_FACTORY(comma_seperated_list) return genre_text
def get_state_strings(self): obj = self.owner int_token = 0 for state_int_data in self.state_value_numbers: state_value = state_int_data.state_value while obj.has_state(state_value.state) and obj.get_state(state_value.state) is state_value: int_token = state_int_data.number break bullet_points = [] for state_string_datas in self.state_value_strings: for state_string_data in state_string_datas: state_value = state_string_data.state_value while obj.has_state(state_value.state) and obj.get_state(state_value.state) is state_value: bullet_point = state_string_data.text(int_token) bullet_points.append(bullet_point) break if bullet_points: if len(bullet_points) == 1: return LocalizationHelperTuning.get_raw_text(bullet_points[0]) return LocalizationHelperTuning.get_bulleted_list(None, *bullet_points)
def root_stock_name_list(self): if not self._fruit_spawners: return name_list = [] for spawner in self._fruit_spawners: tree_fruit_name = spawner.main_spawner.cls._components.gardening_component._tuned_values.fruit_name while tree_fruit_name not in name_list: name_list.append(tree_fruit_name) for (index, name) in enumerate(name_list): name_list[index] = LocalizationHelperTuning.get_object_name(_SplicedFruitData(name)) return name_list
def complete_milestone(self, aspiration, sim_info): aspiration_type = aspiration.aspiration_type() if aspiration_type == AspriationType.FULL_ASPIRATION: sim_info = self._owner_ref() if not (aspiration.is_child_aspiration and sim_info.is_child): return super().complete_milestone(aspiration, sim_info) if aspiration.reward is not None: aspiration.reward.give_reward(sim_info) track = self.active_track if track is None: logger.error('Active track is None when completing full aspiration.') return if aspiration in track.aspirations.values(): if aspiration.screen_slam is not None: aspiration.screen_slam.send_screen_slam_message(sim_info, sim_info, aspiration.display_name, track.display_text) if all(self.milestone_completed(track_aspiration.guid64) for track_aspiration in track.aspirations.values()): if track.reward is not None: reward_payout = track.reward.give_reward(sim_info) else: reward_payout = () reward_text = LocalizationHelperTuning.get_bulleted_list(None, *(reward.get_display_text() for reward in reward_payout)) dialog = track.notification(sim_info, SingleSimResolver(sim_info)) dialog.show_dialog(icon_override=(track.icon, None), secondary_icon_override=(None, sim_info), additional_tokens=(reward_text,), event_id=aspiration.guid64) next_aspiration = track.get_next_aspriation(aspiration) if next_aspiration is not None: self._activate_aspiration(next_aspiration) for objective in next_aspiration.objectives: while objective.set_starting_point(self.data_object): self.update_objective(objective.guid64, 0, objective.goal_value(), objective.is_goal_value_money) else: self._active_aspiration = None with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_COMPLETE_MILESTONE, sim=sim_info.get_sim_instance()) as hook: hook.write_enum('type', aspiration.aspiration_type()) hook.write_guid('guid', aspiration.guid64) services.get_event_manager().process_event(test_events.TestEvent.UnlockEvent, sim_info=sim_info, unlocked=aspiration) elif aspiration_type == AspriationType.FAMILIAL: super().complete_milestone(aspiration, sim_info) for relationship in aspiration.target_family_relationships: family_member_sim_id = sim_info.get_relation(relationship) family_member_sim_info = services.sim_info_manager().get(family_member_sim_id) while family_member_sim_info is not None: services.get_event_manager().process_event(test_events.TestEvent.FamilyTrigger, sim_info=family_member_sim_info, trigger=aspiration) elif aspiration_type == AspriationType.WHIM_SET: self._whimsets_to_reset.add(aspiration.guid64) super().complete_milestone(aspiration, sim_info) self._owner_ref().whim_tracker.activate_set(aspiration) elif aspiration_type == AspriationType.NOTIFICATION: dialog = aspiration.notification(sim_info, SingleSimResolver(sim_info)) dialog.show_dialog(event_id=aspiration.guid64) super().complete_milestone(aspiration, sim_info) else: super().complete_milestone(aspiration, sim_info)
def _ui_metadata_gen(self): additional_information = self._get_additional_information() if additional_information and self.show_gardening_details(): additional_information.sort() object_info_names = [] object_info_descriptions = [] bullet_points = [] for (_, name, value) in additional_information: object_info_names.append(name) object_info_descriptions.append(value) bullet_point = LocalizationHelperTuning.get_name_value_pair(name, value) bullet_points.append(bullet_point) description = LocalizationHelperTuning.get_bulleted_list(None, *bullet_points) plant_name = LocalizationHelperTuning.get_object_name(self.owner.definition) else: object_info_names = None object_info_descriptions = None if GardeningTuning.is_spliced(self.owner): description = self._spliced_description plant_name = GardeningTuning.SPLICED_PLANT_NAME() else: if GardeningTuning.is_shoot(self.owner) and self.root_stock is not None: description = LocalizationHelperTuning.get_object_name(self.root_stock.main_spawner) else: description = LocalizationHelperTuning.get_object_description(self.owner.definition) plant_name = LocalizationHelperTuning.get_object_name(self.owner.definition) subtext = self.owner.get_state_strings() yield ('object_info_names', object_info_names) yield ('object_info_descriptions', object_info_descriptions) yield ('recipe_name', plant_name) yield ('recipe_description', description) if subtext is not None: yield ('subtext', subtext)
def add_aop(self, aop, user_pick_target=None, result_override=DEFAULT, do_test=True): result = ChoiceMenu.is_valid_aop(aop, self.context, self.make_pass, user_pick_target=user_pick_target, result_override=result_override, do_test=do_test) if aop.affordance.allow_user_directed is False: if _show_interaction_failure_reason: if result: failure_result = TestResult(False, tooltip=lambda *_, **__: LocalizationHelperTuning.get_name_value_pair('Failure', 'Not allowed user-directed')) else: failure_result = result self._add_menu_item(aop, failure_result) return result if not result and not result.tooltip: return result self._add_menu_item(aop, result) return result
def populate_protocol_buffer(self, lot_row_data): super().populate_protocol_buffer(lot_row_data.base_data, name_override=LocalizationHelperTuning.get_raw_text(self.name)) logger.assert_raise(self.zone_id is not None, 'No zone_id passed to lot picker row', owner='nbaker') lot_row_data.lot_info_item.zone_id = self.zone_id if self.name is not None: lot_row_data.lot_info_item.name = self.name if self.world_id is not None: lot_row_data.lot_info_item.world_id = self.world_id if self.lot_template_id is not None: lot_row_data.lot_info_item.lot_template_id = self.lot_template_id if self.lot_description_id is not None: lot_row_data.lot_info_item.lot_description_id = self.lot_description_id if self.venue_type_name is not None: lot_row_data.lot_info_item.venue_type_name = self.venue_type_name if self.household_name is not None: lot_row_data.lot_info_item.household_name = self.household_name
def _get_performance_tooltip(self): loc_strings = [] metrics = self.current_level_tuning.performance_metrics if metrics.performance_tooltip is not None: loc_strings.append(metrics.performance_tooltip) for metric in metrics.statistic_metrics: text = metric.tooltip_text while text is not None: if text.general_description: lower_threshold = None stat = self._sim_info.get_statistic(metric.statistic) if stat is not None: (lower_threshold, _) = self._get_statistic_progress_thresholds(stat.stat_type, stat.get_value()) if lower_threshold: description = text.general_description(lower_threshold.text) else: description = text.general_description() loc_strings.append(description) if loc_strings: return LocalizationHelperTuning.get_new_line_separated_strings(*loc_strings)
def _handle_promotion(self): self._pending_promotion = True previous_level_tuning = self.current_level_tuning previous_salary = self.get_hourly_pay() previous_highest_level = self._sim_info.career_tracker.get_highest_level_reached(self.guid64) try: yield None finally: if self.current_level_tuning is not previous_level_tuning: self._pending_promotion = False if self.user_level > previous_highest_level and self.current_level_tuning.promotion_reward is not None: reward_payout = self.current_level_tuning.promotion_reward.give_reward(self._sim_info) reward_text = LocalizationHelperTuning.get_bulleted_list(None, *(reward.get_display_text() for reward in reward_payout)) else: reward_text = None (_, next_work_time, _) = self.get_next_work_time() salary = self.get_hourly_pay() salary_increase = salary - previous_salary level_text = self.current_level_tuning.promotion_notification_text(self._sim_info) is_not_school = not self.get_is_school() if reward_text is None: self.send_career_message(self.career_messages.promote_career_rewardless_notification, next_work_time, salary, salary_increase, level_text, display_career_info=is_not_school) else: self.send_career_message(self.career_messages.promote_career_notification, next_work_time, salary, salary_increase, level_text, reward_text, display_career_info=is_not_school) promotion_sting = self.current_level_tuning.promotion_audio_sting if promotion_sting is not None: play_tunable_audio(promotion_sting) if self.current_level_tuning.screen_slam is not None: self.current_level_tuning.screen_slam.send_screen_slam_message(self._sim_info, self._sim_info, self.current_level_tuning.title(self._sim_info), self.user_level, self.current_track_tuning.career_name(self._sim_info)) if self.has_outfit(): self._sim_info.refresh_current_outfit() else: new_outfit = self._sim_info._outfits.get_outfit_for_clothing_change(None, OutfitChangeReason.DefaultOutfit, resolver=SingleSimResolver(self._sim_info)) self._sim_info.set_current_outfit(new_outfit) with telemetry_helper.begin_hook(career_telemetry_writer, TELEMETRY_HOOK_CAREER_PROMOTION, sim=self._sim_info) as hook: hook.write_int(TELEMETRY_CAREER_ID, self.guid64) hook.write_int(TELEMETRY_CAREER_LEVEL, self._user_level) hook.write_guid(TELEMETRY_TRACK_ID, self._current_track.guid64) hook.write_int(TELEMETRY_TRACK_LEVEL, self._level)
def is_valid_aop(aop, context, make_pass, user_pick_target=None, result_override=DEFAULT, do_test=True): test_result = None result = TestResult.TRUE if result_override is not DEFAULT: result = result_override else: if not make_pass: if user_pick_target is not None and user_pick_target.check_affordance_for_suppression(context.sim, aop, user_directed=True): result = TestResult(False, '{} failed, aop is being suppressed.', aop) else: result = aop.test(context) test_result = str(result) else: result = aop.can_make_test_pass(context) if not result: logger.info('Test Failure: {}: {}', aop, result.reason) if not result: if _show_interaction_failure_reason: result = TestResult(result.result, tooltip=lambda *_, reason=result.reason, **__: LocalizationHelperTuning.get_name_value_pair('Failure', reason)) elif not result.tooltip: result = TestResult(False, '{} failed and has no tooltip', aop) if do_test and make_pass and aop.test(context): result = TestResult(False, '{} already passes', aop) if gsi_handlers.sim_handlers_log.pie_menu_generation_archiver.enabled: gsi_handlers.sim_handlers_log.log_aop_result(context.sim, aop, result, test_result) return result
def _get_display_text(self): return LocalizationHelperTuning.get_money(self._money)
def _get_display_text(self): return LocalizationHelperTuning.get_object_name(self._definition)
def factory(candidate_ingredients, ingredient_ref): for ingredient in candidate_ingredients: while ingredient.id == ingredient_ref.id: return ([ingredient], None, LocalizationHelperTuning.get_object_name(ingredient_ref)) return ([], None, LocalizationHelperTuning.get_object_name(ingredient_ref))
def ui_dialog_notification_test(*all_text, _connection=None): client = services.client_manager().get(_connection) all_text_str = ' '.join(all_text) if '/' in all_text: (title, text) = all_text_str.split('/') notification = UiDialogNotification.TunableFactory().default(client.active_sim, text=lambda **_: LocalizationHelperTuning.get_raw_text(text), title=lambda **_: LocalizationHelperTuning.get_raw_text(title)) else: notification = UiDialogNotification.TunableFactory().default(client.active_sim, text=lambda **_: LocalizationHelperTuning.get_raw_text(all_text_str)) notification.show_dialog(icon_override=(None, client.active_sim))