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)