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 check_add_collection_item(self, household, obj_id, obj_def_id, sim_info=None): (collection_id, _collectible_data, base ) = ObjectCollectionData.get_collection_info_by_definition(obj_def_id) if collection_id is None: return False obj = services.current_zone().find_object(obj_id) if obj_def_id not in self._collections: collection_tracker_data = CollectionTrackerData( collection_id, True, base) if obj is not None: collection_tracker_data.icon_info = create_icon_info_msg( obj.get_icon_info_data()) quality = obj.get_collectible_quality() if quality is not None: collection_tracker_data.quality = quality obj.update_tooltip_field(TooltipFieldsComplete.quality, quality) self._collections[obj_def_id] = collection_tracker_data self.check_collection_complete(collection_id, is_base_collection=base) services.get_event_manager().process_events_for_household( test_events.TestEvent.CollectionChanged, household) msg_type = UI_pb2.CollectibleItemUpdate.TYPE_ADD self.send_collection_msg(msg_type, collection_tracker_data, household.id, obj_def_id, obj_id=obj_id) elif obj is not None: collection_tracker_data = self._collections[obj_def_id] new_quality = obj.get_collectible_quality() if new_quality is not None: obj.update_tooltip_field(TooltipFieldsComplete.quality, new_quality) if new_quality > collection_tracker_data.quality: collection_tracker_data.icon_info = create_icon_info_msg( obj.get_icon_info_data()) collection_tracker_data.quality = new_quality msg_type = UI_pb2.CollectibleItemUpdate.TYPE_DISCOVERY self.send_collection_msg(msg_type, collection_tracker_data, household.id, obj_def_id, obj_id=obj_id) services.get_event_manager().process_event( test_events.TestEvent.CollectedItem, sim_info=sim_info, collection_id=collection_id, collected_item_id=obj_def_id) return True
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 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 __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 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 _fill_notebook_entry_data(self, notebook_subcategory_message, subcategory_tuning, entry, entry_def_id, definition_based, new_entry): active_sim = self._owner.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS) with ProtocolBufferRollback(notebook_subcategory_message.entries) as notebook_entry_message: notebook_entry_message.entry_message = entry.entry_text if entry_def_id is not None: notebook_entry_message.entry_id = entry_def_id if entry.entry_icon_info_data is not None: notebook_entry_message.entry_icon = create_icon_info_msg(entry.entry_icon_info_data) if entry.entry_tooltip is not None: notebook_entry_message.entry_metadata_hovertip.hover_tip = entry.entry_tooltip.tooltip_style for (tooltip_key, tooltip_text) in entry.entry_tooltip.tooltip_fields.items(): setattr(notebook_entry_message.entry_metadata_hovertip, tooltip_key.name, tooltip_text) notebook_entry_message.new_entry = new_entry if entry.entry_sublist: entry_list_description = subcategory_tuning.entry_list_texts.has_list_text if entry_list_description is not None: notebook_entry_message.entry_list_description = entry_list_description if entry.entry_sublist_is_sortable is None: notebook_entry_message.is_sortable = False notebook_entry_message.is_new_item_sortable = False else: notebook_entry_message.is_sortable = True notebook_entry_message.is_new_item_sortable = entry.entry_sublist_is_sortable.include_new_entry for sublist_data in entry.entry_sublist: with ProtocolBufferRollback(notebook_entry_message.entry_list) as notebook_entry_list_message: if sublist_data.is_ingredient: item_message = sublist_data.object_display_name else: item_message = LocalizationHelperTuning.get_object_name(sublist_data.object_definition) notebook_entry_list_message.item_message = item_message if active_sim is not None and sublist_data.num_objects_required > 0: if sublist_data.is_ingredient: notebook_entry_list_message.item_count = sublist_data.item_count else: notebook_entry_list_message.item_count = active_sim.inventory_component.get_count(sublist_data.object_definition) else: notebook_entry_list_message.item_count = 0 notebook_entry_list_message.item_total = sublist_data.num_objects_required notebook_entry_list_message.new_item = sublist_data.new_item if sublist_data.item_icon_info_data is not None: notebook_entry_list_message.item_icon = create_icon_info_msg(sublist_data.item_icon_info_data) if sublist_data.item_tooltip is not None: notebook_entry_list_message.item_tooltip = sublist_data.item_tooltip else: entry_list_description = subcategory_tuning.entry_list_texts.no_list_text if entry_list_description is not None: notebook_entry_message.entry_list_description = entry_list_description
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 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 generate_notebook_information(self, initial_selected_category=None): msg = UI_pb2.NotebookView() if self._notebook_entries: ingredient_cache = StartCraftingMixin.get_default_candidate_ingredients(self._owner.get_sim_instance()) for (index, category_id) in enumerate(self._notebook_entry_catsubcat_cache.keys()): if initial_selected_category is not None: if category_id == initial_selected_category: msg.selected_category_index = index with ProtocolBufferRollback(msg.categories) as notebook_category_message: category_tuning = NotebookTuning.NOTEBOOK_CATEGORY_MAPPING[category_id] notebook_category_message.category_name = category_tuning.category_name if category_tuning.category_description is not None: notebook_category_message.category_description = category_tuning.category_description notebook_category_message.category_icon = create_icon_info_msg(IconInfoData(icon_resource=category_tuning.category_icon)) valid_subcategories = self._notebook_entry_catsubcat_cache[category_id] for subcategory_id in valid_subcategories: with ProtocolBufferRollback(notebook_category_message.subcategories) as notebook_subcategory_message: subcategory_tuning = category_tuning.subcategories[subcategory_id] notebook_subcategory_message.subcategory_id = subcategory_id notebook_subcategory_message.subcategory_name = subcategory_tuning.subcategory_name notebook_subcategory_message.subcategory_icon = create_icon_info_msg(IconInfoData(icon_resource=subcategory_tuning.subcategory_icon)) notebook_subcategory_message.subcategory_tooltip = subcategory_tuning.subcategory_tooltip notebook_subcategory_message.entry_type = subcategory_tuning.format_type if subcategory_tuning.show_max_entries is not None: notebook_subcategory_message.max_num_entries = subcategory_tuning.show_max_entries if subcategory_tuning.is_sortable is None: notebook_subcategory_message.is_sortable = False notebook_subcategory_message.is_new_entry_sortable = False else: notebook_subcategory_message.is_sortable = True notebook_subcategory_message.is_new_entry_sortable = subcategory_tuning.is_sortable.include_new_entry subcategory_entries = self._notebook_entries[subcategory_id] for entry in reversed(subcategory_entries): if entry is None: continue if entry.is_definition_based(): definition_data = entry.get_definition_notebook_data(ingredient_cache=ingredient_cache) if definition_data is not None: self._fill_notebook_entry_data(notebook_subcategory_message, subcategory_tuning, definition_data, entry.entry_object_definition_id, True, entry.new_entry) else: self._fill_notebook_entry_data(notebook_subcategory_message, subcategory_tuning, entry, entry.entry_object_definition_id, False, entry.new_entry) entry.new_entry = False op = GenericProtocolBufferOp(Operation.NOTEBOOK_VIEW, msg) Distributor.instance().add_op(self._owner, op)
def _generate_category_tab_data(self): tab_tuning = self._tuning_data.tab tab_data = BookTabMessage() tab_data.first_page_index = self._first_page_index tooltip = None if tab_tuning.tooltip is not None: tooltip = tab_tuning.tooltip else: tooltip = self._tuning_data.category_name tab_data.icon_info = create_icon_info_msg(IconInfoData(icon_resource=tab_tuning.icon), None, None, tooltip) self._book_helper.set_content_tab_message(self.category_display_type, tab_data)
def build_msg(self, additional_tokens=(), additional_icons=None, **kwargs): msg = super().build_msg(additional_tokens=additional_tokens, **kwargs) msg.dialog_type = Dialog_pb2.UiDialogMessage.ICONS_LABELS for labeled_icon in self.labeled_icons: msg.icon_infos.append( create_icon_info_msg(IconInfoData(labeled_icon.icon), name=self._build_localized_string_msg( labeled_icon.label, *additional_tokens))) if additional_icons: msg.icon_infos.extend(additional_icons) return msg
def _populate_take_photo_op(self, sims, interaction, take_photo_proto): super()._populate_take_photo_op(sims, interaction, take_photo_proto) mood_target_sim = sims[1] if len(sims) > 1 else None if mood_target_sim is not None: take_photo_proto.sim_mood_asm_param_name = mood_target_sim.get_mood_animation_param_name( ) take_photo_proto.randomize_target_sim_order = self.randomize_actors_on_repose mood_categories = itertools.chain( self.DEFAULT_MOOD_CATEGORIES, self.additional_mood_categories ) if self.use_default_mood_categories else self.additional_mood_categories for mood_category in mood_categories: if mood_category.run_tests(sims[0], sims[1:]): with ProtocolBufferRollback( take_photo_proto.mood_categories) as entry: entry.mood_category_up_icon = create_icon_info_msg( IconInfoData(mood_category.icon_tuning.up_icon), tooltip=mood_category.tooltip()) entry.mood_category_down_icon = create_icon_info_msg( IconInfoData(mood_category.icon_tuning.down_icon)) entry.mood_category_over_icon = create_icon_info_msg( IconInfoData(mood_category.icon_tuning.over_icon)) entry.mood_param_values.extend( mood_category.mood_param_values)
def build_end_gig_dialog(self, payout): owner_sim = self._owner resolver = SingleSimResolver(owner_sim) medal = payout.medal payout_display_data = [] self._apply_payout_stat(medal, payout_display_data) additional_icons = [] for additional_payout in payout_display_data: additional_icons.append( create_icon_info_msg( IconInfoData(additional_payout.threshold_icon), name=additional_payout.threshold_description())) end_of_day_dialog = self.end_of_gig_dialog(owner_sim, resolver=resolver) return (end_of_day_dialog, additional_icons)
def _get_restriction_icon_info_msg(self, tracker, object_id, icon_infos, preference_tag, subroot_index=None, description=None): restricted_sim = tracker.get_restricted_sim(object_id, subroot_index, preference_tag) if restricted_sim is None: return sim_info = services.sim_info_manager().get(restricted_sim) if sim_info is None: return icon_info_data = sim_info.get_icon_info_data() icon_infos.append( create_icon_info_msg( icon_info_data, name=LocalizationHelperTuning.get_sim_full_name(sim_info), desc=description))
def build_msg(self, row_data=[], additional_tokens=(), **kwargs): msg = super().build_msg(additional_tokens=additional_tokens, **kwargs) msg.dialog_type = Dialog_pb2.UiDialogMessage.INFO_IN_COLUMNS sim_info = self.owner.sim_info msg.override_sim_icon_id = self.owner.id if self.owner is not None else 0 if sim_info is None: logger.error('Sim Info was None for {}', self._target_sim_id) return msg info_columns_msg = Dialog_pb2.UiDialogInfoInColumns() for column_header in self.column_headers: info_columns_msg.column_headers.append(column_header(sim_info)) for row in row_data: row_data_msg = Dialog_pb2.UiDialogRowData() for (icon, icon_name, icon_description) in row: icon_data = IconInfoData(icon_resource=icon) icon_info_msg = create_icon_info_msg(icon_data, name=icon_name, desc=icon_description) row_data_msg.column_info.append(icon_info_msg) info_columns_msg.rows.append(row_data_msg) msg.info_in_columns_data = info_columns_msg return msg
def send_lot_display_info(self): lot_name = self.get_lot_name() household = self.get_household() if household is not None: owner_household_name = household.name else: owner_household_name = None msg = UI_pb2.LotDisplayInfo() if lot_name is not None: msg.lot_name = lot_name if owner_household_name is not None: msg.household_name = owner_household_name zone_modifier_display_infos = services.get_zone_modifier_service( ).get_zone_modifier_display_infos(self.zone_id) for display_info in zone_modifier_display_infos: msg.icon_infos.append( create_icon_info_msg( IconInfoData( icon_resource=display_info.zone_modifier_icon))) op = distributor.shared_messages.create_message_op( msg, Consts_pb2.MSG_UI_LOT_DISPLAY_INFO) Distributor.instance().add_op_with_no_owner(op)
def start_live_drag(self, live_drag_object, start_system, is_stack, should_send_start_message: bool = True): self._live_drag_start_system = start_system success = True if is_stack: inventoryitem_component = live_drag_object.inventoryitem_component stack_id = inventoryitem_component.get_stack_id() current_inventory = inventoryitem_component.get_inventory() stack_items = current_inventory.get_stack_items(stack_id) else: stack_items = [live_drag_object] for item in stack_items: live_drag_component = live_drag_object.live_drag_component live_drag_component = item.live_drag_component if live_drag_component is None: logger_live_drag.error( 'Live Drag Start called on an object with no Live Drag Component. Object: {}' .format(item)) self.send_live_drag_cancel(live_drag_object.id) return if not ((not item.in_use or item.in_use_by(self)) and live_drag_component.can_live_drag): logger_live_drag.warn( 'Live Drag Start called on an object that is in use. Object: {}' .format(item)) self.send_live_drag_cancel(item.id) return success = live_drag_component.start_live_dragging( self, start_system) if not success: break self._live_drag_objects.append(item) if not success: self.cancel_live_drag_on_objects() self.send_live_drag_cancel(live_drag_object.id, LiveDragLocation.INVALID) self._live_drag_is_stack = is_stack if gsi_handlers.live_drag_handlers.live_drag_archiver.enabled: gsi_handlers.live_drag_handlers.archive_live_drag( 'Start', 'Operation', LiveDragLocation.GAMEPLAY_SCRIPT, start_system, live_drag_object_id=live_drag_object.id) if live_drag_object.live_drag_component.active_household_has_sell_permission: sell_value = self.get_live_drag_object_value( live_drag_object, self._live_drag_is_stack ) if live_drag_object.definition.get_is_deletable() else -1 for child_object in live_drag_object.get_all_children_gen(): sell_value += self.get_live_drag_object_value( child_object) if child_object.definition.get_is_deletable( ) else 0 else: sell_value = -1 (valid_drop_object_ids, valid_stack_id) = live_drag_component.get_valid_drop_object_ids() icon_info = create_icon_info_msg(live_drag_object.get_icon_info_data()) if should_send_start_message: op = distributor.ops.LiveDragStart(live_drag_object.id, start_system, valid_drop_object_ids, valid_stack_id, sell_value, icon_info) distributor_system = Distributor.instance() distributor_system.add_op_with_no_owner(op)
def send_perks_list_for_bucks_type(self, bucks_type, sort_key=None, reverse=True): bucks_msg = Dialog_pb2.GameplayPerkList() bucks_msg.bucks_type = bucks_type resolver = SingleSimResolver(self._owner) perk_messages = [] for perk in self.all_perks_of_type_gen(bucks_type): perk_message = Dialog_pb2.GameplayPerk() perk_message.id = perk.guid64 perk_message.display_name = perk.display_name() perk_message.description = self._get_description_string(perk) perk_message.icon = create_icon_info_msg( IconInfoData(icon_resource=perk.icon.key)) perk_message.cost = perk.unlock_cost if bucks_type not in self._bucks: self._bucks[bucks_type] = 0 perk_message.affordable = self._bucks[ bucks_type] >= perk.unlock_cost perk_message.ui_display_flags = perk.ui_display_flags if perk.required_unlocks is not None: locked = False for required_perk in perk.required_unlocks: if not self.is_perk_unlocked(required_perk): locked = True perk_message.required_perks.append(required_perk.guid64) perk_message.locked = locked result = perk.available_for_puchase_tests.run_tests( resolver=resolver, search_for_tooltip=True) if not result: perk_message.locked_from_tests = True if result.tooltip is not None: perk_message.disabled_tooltip = result.tooltip(self._owner) unlocked = self.is_perk_unlocked(perk) if unlocked: perk_message.purchased = unlocked timestamp = self._get_perk_unlock_timestamp(perk) if timestamp is not None: perk_message.unlock_timestamp = timestamp if not unlocked: if self.is_perk_recently_locked(perk): perk_message.recently_locked = True if unlocked: disabled_tooltip = self.get_disabled_tooltip_for_perk(perk) if disabled_tooltip is not None: perk_message.disabled_tooltip = disabled_tooltip if perk.lock_on_purchase: for perk_to_lock in perk.lock_on_purchase: perk_message.lock_on_purchase.append(perk_to_lock.guid64) if perk.next_level_perk is not None: perk_message.next_perk_id = perk.next_level_perk.guid64 if perk.conflicting_perks is not None: for conflicting_perk in perk.conflicting_perks: perk_message.conflicting_perks.append( conflicting_perk.guid64) perk_messages.append(perk_message) if sort_key is not None: perk_messages.sort(key=sort_key, reverse=reverse) bucks_msg.perk_list.extend(perk_messages) op = shared_messages.create_message_op( bucks_msg, Consts_pb2.MSG_GAMEPLAY_PERK_LIST) Distributor.instance().add_op_with_no_owner(op)
def _create_org_event_info(event_info_msg, org_event_info): event_info_msg.drama_node_id = org_event_info._drama_node.guid64 _populate_scheduler_msg(event_info_msg.schedule, org_event_info._schedule, org_event_info._fake_duration) event_info_msg.event_info = create_icon_info_msg(org_event_info._icon_info, name=org_event_info._name, desc=org_event_info._description) event_info_msg.location = org_event_info._location event_info_msg.zone_id = org_event_info._zone_id
def show_dialog(cls, retail_manager, is_from_close=False): business_tuning = retail_manager.tuning_data report_msg = protocolbuffers.Dialog_pb2.RetailSummaryDialog() report_msg.name = LocalizationHelperTuning.get_raw_text( retail_manager.get_lot_name()) report_msg.subtitle = business_tuning.summary_dialog_subtitle report_msg.icon = create_icon_info_msg( IconInfoData(business_tuning.summary_dialog_icon)) timespan_since_open = retail_manager.get_timespan_since_open( is_from_close) report_msg.hours_open = round(timespan_since_open.in_hours( )) if timespan_since_open is not None else 0 report_msg.total_amount = retail_manager.get_daily_net_profit() if retail_manager.is_open: report_msg.total_amount -= retail_manager.get_total_employee_wages( ) items_sold_line_item = report_msg.line_items.add() items_sold_line_item.name = business_tuning.summary_dialog_transactions_header items_sold_line_item.item_type = business_tuning.summary_dialog_transactions_text( retail_manager.daily_items_sold) items_sold_line_item.value = retail_manager.daily_revenue for sim_info in sorted(retail_manager.get_employees_on_payroll(), key=operator.attrgetter('last_name')): current_career_level = retail_manager.get_employee_career_level( sim_info) with ProtocolBufferRollback( report_msg.line_items) as line_item_msg: payroll_entries = [] for (career_level, hours_worked) in sorted( retail_manager.get_employee_wages_breakdown_gen( sim_info), key=lambda wage: -wage[0].simoleons_per_hour): if not hours_worked and career_level is not current_career_level: continue payroll_entries.append( business_tuning.summary_dialog_payroll_text( career_level.get_title(sim_info), career_level.simoleons_per_hour, hours_worked)) if not payroll_entries: raise ProtocolBufferRollbackExpected line_item_msg.name = business_tuning.summary_dialog_payroll_header( sim_info) line_item_msg.item_type = LocalizationHelperTuning.get_new_line_separated_strings( *payroll_entries) line_item_msg.value = -retail_manager.get_employee_wages( sim_info) wages_owed_line_item = report_msg.line_items.add() wages_owed_line_item.name = business_tuning.summary_dialog_wages_owed_header wages_owed_line_item.item_type = business_tuning.summary_dialog_wages_owed_text( retail_manager.get_total_employee_wages()) wages_owed_line_item.value = -retail_manager.get_total_employee_wages() for (entry_name, entry_value) in retail_manager.get_funds_category_entries_gen(): with ProtocolBufferRollback( report_msg.line_items) as line_item_msg: line_item_msg.name = LocalizationHelperTuning.get_raw_text('') line_item_msg.item_type = entry_name line_item_msg.value = -entry_value report_op = GenericProtocolBufferOp( DistributorOps_pb2.Operation.RETAIL_SUMMARY_DIALOG, report_msg) Distributor.instance().add_op_with_no_owner(report_op)