def save_interactions(self):
interaction_save_state = gameplay_serialization.SuperInteractionSaveState()
sorted_sis = sorted(self._super_interactions, key=lambda si: return 0 if self.sim.posture_state.is_source_interaction(si) else 1)
for si in sorted_sis:
if not si.saveable:
pass
with ProtocolBufferRollback(interaction_save_state.interactions) as si_save_data:
si.fill_save_data(si_save_data)
sim_queue = self.sim.queue
transition_controller = sim_queue.transition_controller
interaction = None if transition_controller is None else transition_controller.interaction
if interaction is not None:
is_transitioning = interaction.transition is not None and (interaction.transition.running and interaction.pipeline_progress < PipelineProgress.RUNNING)
if is_transitioning and interaction.saveable:
transitioning_interaction = interaction_save_state.transitioning_interaction
interaction.fill_save_data(transitioning_interaction.base_interaction_data)
current_sim_posture = self.sim.posture_state
if current_sim_posture is not None:
transitioning_interaction.posture_aspect_body = current_sim_posture.body.guid64
transitioning_interaction.posture_carry_left = current_sim_posture.left.guid64
transitioning_interaction.posture_carry_right = current_sim_posture.right.guid64
for si in sim_queue.queued_super_interactions_gen():
if not si.is_super:
pass
if not si.saveable:
pass
if si is interaction:
pass
with ProtocolBufferRollback(interaction_save_state.queued_interactions) as si_save_data:
si.fill_save_data(si_save_data)
return interaction_save_state
def save_whims_info_to_proto(self, whim_tracker_proto):
if self._sim_info.is_npc:
return
for (whim, whimset) in self._realized_goals.items():
with ProtocolBufferRollback(
whim_tracker_proto.whims_to_whimsets) as whim_whimset_pair:
whim_whimset_pair.whim_guid64 = whim.guid64
whim_whimset_pair.whimset_guid64 = whimset.guid64
for (whimset, target) in self._whimset_target_map.items():
while target is not None:
with ProtocolBufferRollback(whim_tracker_proto.whims_to_targets
) as whim_target_pair:
for (whim, source_set) in self._realized_goals.items():
while source_set.guid64 == whimset.guid64:
whim_target_pair.whim_guid64 = whim.guid64
break
while whim_target_pair.whim_guid64 != 0:
whim_target_pair.target_id = target.id
if len(self._realized_goals) > self.MAX_GOALS + 1:
logger.error('Trying to save too many whims. Current whims: {}',
self._realized_goals.keys(),
owner='jjacobson')
for given_goal in self._realized_goals.keys():
goal_seed = given_goal.create_seedling()
goal_seed.finalize_creation_for_save()
with ProtocolBufferRollback(
whim_tracker_proto.whim_goals) as goal_proto:
goal_seed.serialize_to_proto(goal_proto)
def save_data(self):
household_msg = services.get_persistence_service(
).get_household_proto_buff(self.id)
if household_msg is None:
household_msg = services.get_persistence_service(
).add_household_proto_buff()
inventory = serialization.ObjectList()
inventory.CopyFrom(household_msg.inventory)
household_msg.Clear()
household_msg.account_id = self.account.id
household_msg.household_id = self.id
household_msg.name = self.name
household_msg.description = self.description
household_msg.home_zone = self.home_zone_id
household_msg.last_modified_time = self.last_modified_time
household_msg.money = self.funds.money
household_msg.hidden = self.hidden
household_msg.creator_id = self.creator_id
household_msg.creator_name = self.creator_name
if self.creator_uuid is not None:
household_msg.creator_uuid = self.creator_uuid
household_msg.inventory = inventory
household_msg.reward_inventory = self._reward_inventory
household_msg.gameplay_data.build_buy_unlock_list = ResourceKey_pb2.ResourceKeyList(
)
for unlock in self.build_buy_unlocks:
if isinstance(unlock, int):
unlock = sims4.resources.Key(Types.OBJCATALOG, unlock, 0)
key_proto = sims4.resources.get_protobuff_for_key(unlock)
household_msg.gameplay_data.build_buy_unlock_list.resource_keys.append(
key_proto)
household_msg.gameplay_data.situation_scoring_enabled = self._situation_scoring_enabled
if self.sim_in_household(self._last_active_sim_id):
household_msg.last_played = self._last_active_sim_id
household_msg.is_npc = self.is_persistent_npc
household_msg.gameplay_data.billable_household_value = self.household_net_worth(
billable=True)
household_msg.gameplay_data.ClearField(
'highest_earned_situation_medals')
for (situation_id,
medal) in self._highest_earned_situation_medals.items():
with ProtocolBufferRollback(
household_msg.gameplay_data.highest_earned_situation_medals
) as situation_medal:
situation_medal.situation_id = situation_id
situation_medal.medal = medal
self.bills_manager.save_data(household_msg)
self.collection_tracker.save_data(household_msg)
if self._service_npc_record is not None:
for service_record in self._service_npc_record.values():
with ProtocolBufferRollback(household_msg.gameplay_data.
service_npc_records) as record_msg:
service_record.save_npc_record(record_msg)
id_list = serialization.IdList()
for sim_info in self:
id_list.ids.append(sim_info.id)
household_msg.sims = id_list
return True
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_situation_start_message(self):
msg = super().build_situation_start_message()
with ProtocolBufferRollback(msg.meter_data) as meter_data_msg:
self.mother_plant_meter_settings.build_data_message(meter_data_msg)
with ProtocolBufferRollback(msg.meter_data) as meter_data_msg:
self.player_health_meter_settings.build_data_message(
meter_data_msg)
build_icon_info_msg(IconInfoData(icon_resource=self.mother_plant_icon),
None, msg.icon_info)
return msg
def save(self, save_slot_data=None, **kwargs):
holiday_service_proto = GameplaySaveData_pb2.PersistableHolidayService(
)
for custom_holiday in self._holidays.values():
with ProtocolBufferRollback(
holiday_service_proto.holidays) as holiday_data:
custom_holiday.save_holiday(holiday_data)
for calendar in self._holiday_times.values():
with ProtocolBufferRollback(
holiday_service_proto.calendars) as calendar_msg:
calendar.save(calendar_msg)
save_slot_data.gameplay_data.holiday_service = holiday_service_proto
def serialize_to_proto(self, goal_tracker_proto):
goal_tracker_proto.has_offered_goals = self._has_offered_goals
goal_tracker_proto.inherited_target_id = self._inherited_target_id
for chain in self._chains:
with ProtocolBufferRollback(
goal_tracker_proto.chains) as chain_proto:
chain.serialize_to_proto(chain_proto)
if self._main_goal:
self._main_goal.serialize_to_proto(goal_tracker_proto.main_goal)
for goal in self._minor_goals:
with ProtocolBufferRollback(
goal_tracker_proto.minor_goals) as goal_proto:
goal.serialize_to_proto(goal_proto)
def save(self):
data = protocols.PersistableAdventureTracker()
for (adventure_id, adventure_moment_id) in self._adventure_mappings.items():
with ProtocolBufferRollback(data.adventures) as adventure_pair:
adventure_pair.adventure_id = adventure_id
adventure_pair.adventure_moment_id = adventure_moment_id
for (adventure_id, adventure_moment_dict) in self._adventure_cooldowns.items():
for (adventure_moment_id, cooldown) in adventure_moment_dict.items():
with ProtocolBufferRollback(data.adventure_cooldowns) as adventure_cooldown_data:
adventure_cooldown_data.adventure_id = adventure_id
adventure_cooldown_data.adventure_moment_id = adventure_moment_id
adventure_cooldown_data.adventure_cooldown = cooldown
return data
def serialize_to_proto(self, seed_proto):
seed_proto.situation_type_id = self._situation_type.guid64
seed_proto.situation_id = self._situation_id
seed_proto.seed_purpose = self._purpose
seed_proto.host_sim_id = self._guest_list._host_sim_id
seed_proto.filter_requesting_sim_id = self._guest_list.filter_requesting_sim_id
seed_proto.invite_only = self._guest_list.invite_only
seed_proto.user_facing = self._user_facing
if self._duration_override is not None:
seed_proto.duration = self._duration_override
seed_proto.zone_id = self._zone_id
seed_proto.score = self.score
if self._travel_time is not None:
seed_proto.create_time = self._travel_time.absolute_ticks()
seed_proto.start_time = self._start_time.absolute_ticks() if self._start_time is not None else date_and_time.INVALID_DATE_AND_TIME
seed_proto.scoring_enabled = self._scoring_enabled
seed_proto.main_goal_visibility = self._main_goal_visiblity
seed_proto.linked_sim_id = self._linked_sim_id
for job_type in self._guest_list.get_set_of_jobs():
for guest_info in self._guest_list.get_guest_infos_for_job(job_type):
with ProtocolBufferRollback(seed_proto.assignments) as assignment:
assignment.sim_id = guest_info.sim_id
assignment.job_type_id = guest_info.job_type.guid64
assignment.request_priority = guest_info.request_priority
assignment.spawning_option = guest_info.spawning_option
assignment.expectation_preference = guest_info.expectation_preference
assignment.accept_alternate_sim = guest_info.accept_alternate_sim
assignment.common_blacklist_categories = guest_info.common_blacklist_categories
assignment.elevated_importance_override = guest_info.elevated_importance_override
assignment.reservation = guest_info.reservation
if guest_info.persisted_role_state_type is not None:
assignment.role_state_type_id = guest_info.persisted_role_state_type.guid64
for (job_type, job_data) in self._job_data.items():
with ProtocolBufferRollback(seed_proto.jobs_and_role_states) as data:
data.job_type_id = job_type.guid64
data.role_state_type_id = job_data.role_state_type.guid64
if job_data.emotional_loot_actions_type is not None:
data.emotional_loot_actions_type_id = job_data.emotional_loot_actions_type.guid64
if self._simple is not None:
seed_proto.simple_data.phase_index = self._simple.phase_index
seed_proto.simple_data.remaining_phase_time = self._simple.remaining_phase_time
elif self._complex is not None:
data = self._complex.situation_custom_data
if data is not None:
seed_proto.complex_data.situation_custom_data = data
data = self._complex.state_custom_data
if data is not None:
seed_proto.complex_data.state_custom_data = data
if self._goal_tracker:
self._goal_tracker.serialize_to_proto(seed_proto.goal_tracker_data)
def save(self):
save_data = protocolbuffers.SimObjectAttributes_pb2.PersistableSimCareers()
for career in self._careers.values():
with ProtocolBufferRollback(save_data.careers) as career_proto:
career_proto.MergeFrom(career.get_persistable_sim_career_proto())
for (career_uid, career_history) in self._career_history.items():
with ProtocolBufferRollback(save_data.career_history) as career_history_proto:
career_history_proto.career_uid = career_uid
career_history.save_career_history(career_history_proto)
if self._retirement is not None:
save_data.retirement_career_uid = self._retirement.career_uid
if self._custom_data is not None:
self._custom_data.save_custom_data(save_data)
return save_data
def get_situation_data(session_id: int = 0,
sim_id: OptionalTargetParam = None,
*situation_ids,
_connection=None):
sim = get_optional_target(sim_id, _connection)
instance_manager = services.situation_manager()
situation_batch_msg = Situations_pb2.SituationDataBatch()
situation_batch_msg.situation_session_id = session_id
for situation_id in situation_ids:
with ProtocolBufferRollback(
situation_batch_msg.situations) as situation_data:
instance = instance_manager.get(situation_id)
while instance is not None:
shared_messages.build_icon_info_msg((instance._icon, None),
instance._display_name,
situation_data.icon_info)
situation_data.icon_info.desc = instance.situation_description
situation_data.cost = instance._cost
situation_data.max_participants = instance.max_participants
for medal in SituationMedal:
with ProtocolBufferRollback(
situation_data.rewards) as reward_msg:
level = instance.get_level_data(medal)
reward_msg.level = int(medal)
while level is not None and level.reward is not None:
reward_msg.display_name.extend(
[level.reward.reward_description])
jobs = list(instance.get_tuned_jobs())
jobs.sort(key=lambda job: job.guid64)
if instance.job_display_ordering is not None:
for ordered_job in reversed(instance.job_display_ordering):
while ordered_job in jobs:
jobs.remove(ordered_job)
jobs.insert(0, ordered_job)
for job in jobs:
while job.sim_count.upper_bound > 0:
with ProtocolBufferRollback(
situation_data.jobs) as job_msg:
job_msg.job_resource_id = job.guid64
shared_messages.build_icon_info_msg(
(job.icon, None), job.display_name,
job_msg.icon_info)
job_msg.icon_info.desc = job.job_description
job_msg.is_hireable = job.can_be_hired
job_msg.min_required = job.sim_count.lower_bound
job_msg.max_allowed = job.sim_count.upper_bound
job_msg.hire_cost = job.hire_cost
shared_messages.add_message_if_selectable(
sim, Consts_pb2.MSG_SITUATION_DATA_BATCH, situation_batch_msg, True)
def save_notebook(self):
notebook_tracker_data = protocols.PersistableNotebookTracker()
for category_list in self._notebook_entries.values():
for entry in category_list:
with ProtocolBufferRollback(notebook_tracker_data.notebook_entries) as entry_data:
entry_data.tuning_reference_id = entry.guid64
entry_data.new_entry = entry.new_entry
if entry.is_definition_based():
if entry.entry_object_definition_id is not None:
entry_data.object_recipe_id = entry.entry_object_definition_id
for sub_entry in entry.sub_entries:
with ProtocolBufferRollback(entry_data.object_sub_entries) as sub_entry_data:
sub_entry_data.sub_entry_id = sub_entry.sub_entry_id
sub_entry_data.new_sub_entry = sub_entry.new_sub_entry
return notebook_tracker_data
def save(self, event_data_blob):
for tag in self._tags.keys():
with ProtocolBufferRollback(event_data_blob.tag_data) as tag_data:
for (data_type, data) in self.get_tag_data(tag).items():
if data_type == data_const.TagData.TimeElapsed:
amount = data.in_ticks()
else:
amount = data
if amount == 0:
continue
with ProtocolBufferRollback(
tag_data.enums) as tag_data_groups:
tag_data_groups.enum = data_type
tag_data_groups.amount = amount
tag_data.tag_enum = tag
def _save_clean_up_destination_data(self, current_zone,
objects_to_save_for_clean_up,
save_game_protocol_buffer):
household_manager = services.household_manager()
travel_group_manager = services.travel_group_manager()
clean_up_save_data = None
for object_data in sorted(objects_to_save_for_clean_up,
key=lambda x: x.owner_id):
owner_id = object_data.owner_id
if clean_up_save_data is None or clean_up_save_data.household_id != owner_id:
household = household_manager.get(owner_id)
travel_group = None
if household is not None:
travel_group = household.get_travel_group()
for clean_up_save_data in save_game_protocol_buffer.destination_clean_up_data:
if clean_up_save_data.household_id != owner_id:
continue
if travel_group is not None:
if travel_group.id == clean_up_save_data.travel_group_id:
break
if clean_up_save_data.travel_group_id in travel_group_manager:
continue
break
with ProtocolBufferRollback(
clean_up_save_data.object_clean_up_data_list
) as object_clean_up_data:
if object_data.loc_type == ItemLocation.ON_LOT:
object_clean_up_data.zone_id = current_zone.id
else:
object_clean_up_data.world_id = current_zone.open_street_id
object_clean_up_data.object_data = object_data
def save(self, object_list=None, zone_data=None, open_street_data=None, store_travel_group_placed_objects=False, save_slot_data=None):
if zone_data is None:
return
for ensemble in self.get_all_ensembles():
with ProtocolBufferRollback(zone_data.gameplay_zone_data.ensemble_service_data.ensemble_datas) as ensemble_data:
ensemble_data.ensemble_type_id = ensemble.guid64
ensemble_data.sim_ids.extend(sim.id for sim in ensemble)
def _build_response_arg (self, response, response_msg, tutorial_id = None, additional_tokens = (), response_command_tuple = None, **kwargs): response_msg.choice_id = response.dialog_response_id response_msg.ui_request = response.ui_request if response.text is not None: response_msg.text = self._build_localized_string_msg(response.text, *additional_tokens) if response.subtext is not None: response_msg.subtext = response.subtext if response.disabled_text is not None: response_msg.disabled_text = response.disabled_text if tutorial_id is not None: response_msg.tutorial_args.tutorial_id = tutorial_id if response.response_command: response_msg.command_with_args.command_name = response.response_command.command for argument in response.response_command.arguments: with ProtocolBufferRollback(response_msg.command_with_args.command_remote_args.args) as entry: if argument.arg_type == CommandArgType.ARG_TYPE_SPECIAL: arg_type = response_command_tuple[0] arg_value = response_command_tuple[1] elif argument.arg_type == CommandArgType.ARG_TYPE_RESOLVED: (arg_type, arg_value) = argument.resolve_response_arg(self._resolver) else: arg_type = argument.arg_type arg_value = argument.arg_value if arg_type == CommandArgType.ARG_TYPE_BOOL: entry.bool = arg_value elif arg_type == CommandArgType.ARG_TYPE_STRING: entry.string = arg_value elif arg_type == CommandArgType.ARG_TYPE_FLOAT: entry.float = arg_value elif arg_type == CommandArgType.ARG_TYPE_INT: entry.int64 = arg_value
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 serialize_seeds_to_open_street(cls, open_street_seeds=None, open_street_data_msg=None):
if open_street_seeds is None or open_street_data_msg is None:
return
open_street_data_msg.ClearField('situation_seeds')
for seed in open_street_seeds:
with ProtocolBufferRollback(open_street_data_msg.situation_seeds) as seed_proto:
seed.serialize_to_proto(seed_proto)
def _apply_to_subject_and_target(self, subject, target, resolver):
canvas_texture_id = target.canvas_component.get_canvas_texture_id()
composite_target_effect = target.canvas_component.painting_state.effect
op = CompositeImages(canvas_texture_id, composite_target_effect, target.id)
with ProtocolBufferRollback(op.op.additional_composite_operations) as additional_composite_operations:
additional_composite_operations.texture_hash = self.overlay_image.instance
Distributor.instance().add_op_with_no_owner(op)
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 save_genealogy(self):
save_data = protocols.PersistableGenealogyTracker()
for (relation, sim_id) in self._family_relations.items():
with ProtocolBufferRollback(save_data.family_relations) as entry:
entry.relation_type = relation
entry.sim_id = sim_id
return save_data
def populate_focus_score_entry_msg(self, focus_score_entry_msg):
focus_score_entry_msg.base = FocusTuning.FOCUS_SCORE_VALUES[self.base]
for (trait, multiplier) in self.multipliers.items():
with ProtocolBufferRollback(focus_score_entry_msg.multipliers
) as focus_score_entry_multiplier_msg:
focus_score_entry_multiplier_msg.trait_id = trait.guid64
focus_score_entry_multiplier_msg.multiplier = multiplier
def write_slave_data_msg(self, route_msg, path=None):
transitioning_sims = ()
actor = self.owner
if actor.is_sim:
if actor.transition_controller is not None:
transitioning_sims = actor.transition_controller.get_transitioning_sims()
for slave_data in self.get_routing_slave_data():
if slave_data.should_slave_for_path(path):
if slave_data.slave in transitioning_sims:
continue
(slave_actor, slave_msg) = slave_data.add_routing_slave_to_pb(route_msg, path=path)
slave_actor.write_slave_data_msg(slave_msg, path=path)
for slave_actor in actor.children:
if not slave_actor.is_sim:
continue
carry_walkstyle_behavior = slave_actor.get_walkstyle_behavior().carry_walkstyle_behavior
if carry_walkstyle_behavior is None:
continue
with ProtocolBufferRollback(route_msg.slaves) as slave_msg:
slave_msg.id = slave_actor.id
slave_msg.type = Routing_pb2.SlaveData.SLAVE_PAIRED_CHILD
walkstyle_override_msg = slave_msg.walkstyle_overrides.add()
walkstyle_override_msg.from_walkstyle = 0
walkstyle_override_msg.to_walkstyle = carry_walkstyle_behavior.default_carry_walkstyle
for (walkstyle, carry_walkstyle) in carry_walkstyle_behavior.carry_walkstyle_overrides.items():
walkstyle_override_msg = slave_msg.walkstyle_overrides.add()
walkstyle_override_msg.from_walkstyle = walkstyle
walkstyle_override_msg.to_walkstyle = carry_walkstyle
slave_actor.write_slave_data_msg(slave_msg, path=path)
def send_selectable_sims_update(self):
msg = Sims_pb2.UpdateSelectableSims()
for sim_info in self._selectable_sims:
with ProtocolBufferRollback(msg.sims) as new_sim:
new_sim.id = sim_info.sim_id
if sim_info.career_tracker is None:
logger.error(
'CareerTracker is None for selectable Sim {}'.format(
sim_info))
else:
career = sim_info.career_tracker.get_currently_at_work_career(
)
new_sim.at_work = career is not None and not career.is_at_active_event
new_sim.is_selectable = sim_info.is_enabled_in_skewer
(selector_visual_type,
career_category) = self._get_selector_visual_type(sim_info)
new_sim.selector_visual_type = selector_visual_type
if career_category is not None:
new_sim.career_category = career_category
new_sim.can_care_for_toddler_at_home = sim_info.can_care_for_toddler_at_home
if not sim_info.is_instanced(
allow_hidden_flags=ALL_HIDDEN_REASONS):
new_sim.instance_info.zone_id = sim_info.zone_id
new_sim.instance_info.world_id = sim_info.world_id
new_sim.firstname = sim_info.first_name
new_sim.lastname = sim_info.last_name
zone_data_proto = services.get_persistence_service(
).get_zone_proto_buff(sim_info.zone_id)
if zone_data_proto is not None:
new_sim.instance_info.zone_name = zone_data_proto.name
distributor = Distributor.instance()
distributor.add_op_with_no_owner(
GenericProtocolBufferOp(Operation.SELECTABLE_SIMS_UPDATE, msg))
def populate_focus_score_msg(self, focus_score_msg):
for (species, focus_score) in self.scores.items():
with ProtocolBufferRollback(
focus_score_msg.specific_scores) as focus_score_entry_msg:
focus_score_entry_msg.species = species
focus_score.populate_focus_score_entry_msg(
focus_score_entry_msg.score)
def _build_journal_entry(self, journal_seed):
op = journal_seed.op
object_id = journal_seed.object_id
manager_id = journal_seed.manager_id
object_name = journal_seed.debug_object_name
proto_buff = protocolbuffers.DistributorOps_pb2.Operation()
mask_override = None
if manager_id == MGR_UNMANAGED:
mask_override = 0
if op._force_execution_on_tag:
mask_override = 0
elif op._primary_channel_mask_override is not None:
mask_override = op._primary_channel_mask_override
if mask_override is not None:
if mask_override != DEFAULT_MASK:
proto_buff.primary_channel_mask_override = mask_override
for channel in op._additional_channels:
with ProtocolBufferRollback(
proto_buff.additional_channels) as additional_channel_msg:
additional_channel_msg.id.manager_id = channel[0]
additional_channel_msg.id.object_id = channel[1]
if channel[1] == object_id and mask_override is not None:
additional_channel_msg.mask = mask_override
else:
additional_channel_msg.mask = channel[2]
op.write(proto_buff)
if not proto_buff.IsInitialized():
logger.error(
'Message generated by {} is missing required fields: ' +
str(proto_buff.FindInitializationErrors()), op)
payload_type = op.payload_type
entry = Journal.JournalEntry(object_id, proto_buff, payload_type,
manager_id, object_name)
return entry
def populate_employee_msg(self, sim_info, employee_msg, business_employee_type, business_employee_data):
employee_msg.sim_id = sim_info.sim_id
employee_data = self._employee_manager.get_employee_data(sim_info)
employee_is_training = sim_info.has_buff_with_tag(self.tuning_data.employee_training_buff_tag)
for (skill_type, skill_type_data) in business_employee_data.employee_skills.items():
with ProtocolBufferRollback(employee_msg.skill_data) as employee_skill_msg:
employee_skill_msg.skill_id = skill_type.guid64
employee_skill_msg.curr_points = int(sim_info.get_stat_value(skill_type))
employee_skill_msg.is_training = employee_is_training
employee_skill_msg.has_skilled_up = employee_data.has_leveled_up_skill(skill_type) if employee_data is not None else False
employee_skill_msg.skill_tooltip = skill_type_data.business_summary_description
if self.is_employee(sim_info):
satisfaction_stat = sim_info.get_statistic(business_employee_data.satisfaction_commodity)
statisfaction_state_index = satisfaction_stat.get_state_index()
if statisfaction_state_index is not None:
employee_msg.satisfaction_string = satisfaction_stat.states[statisfaction_state_index].buff.buff_type.buff_name(sim_info)
career_level = self.get_employee_career_level(sim_info)
employee_msg.pay = career_level.simoleons_per_hour
career = self.get_employee_career(sim_info)
employee_msg.current_career_level = career.level
employee_msg.max_career_level = len(career.current_track_tuning.career_levels) - 1
else:
desired_level = self.get_desired_career_level(sim_info, business_employee_type)
career_level = business_employee_data.career.start_track.career_levels[desired_level]
employee_msg.pay = career_level.simoleons_per_hour
employee_msg.current_career_level = desired_level
employee_msg.max_career_level = len(business_employee_data.career.start_track.career_levels) - 1
def _send_relationship_data(self, sim_id):
if self.relationship_track_visual is None:
return
relationship_to_send = self._get_relationship(sim_id)
if not relationship_to_send:
return
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is None:
return
msg = commodity_protocol.RelationshipUpdate()
msg.actor_sim_id = sim_id
(msg.target_id.object_id,
msg.target_id.manager_id) = self.owner.icon_info
msg.target_instance_id = self.owner.id
if self.icon_override is not None:
build_icon_info_msg(IconInfoData(icon_resource=self.icon_override),
None, msg.target_icon_override)
with ProtocolBufferRollback(msg.tracks) as relationship_track_update:
relationship_value = relationship_to_send.get_value()
relationship_track_update.track_score = relationship_value
relationship_track_update.track_bit_id = self.relationship_track_visual.relationship_track.get_bit_at_relationship_value(
relationship_value).guid64
relationship_track_update.track_id = self.relationship_track_visual.relationship_track.guid64
relationship_track_update.track_popup_priority = self.relationship_track_visual.relationship_track.display_popup_priority
relationship_track_update.visible_in_relationship_panel = self.relationship_track_visual.visible_in_relationship_panel
send_relationship_op(sim_info, msg)
if self._object_social_mixin is not None:
self._object_social_mixin.send_social_update_message()
def __init__(self, awareness_modifiers):
super().__init__()
self.op = Animation_pb2.ConfigureAwarenessActor()
for (awareness_channel, awareness_options) in awareness_modifiers.items():
if awareness_channel in (self.PROXIMITY_INNER_RADIUS, self.PROXIMITY_OUTER_RADIUS):
continue
if not awareness_options:
awareness_options = DEFAULT
else:
awareness_options = awareness_options[0]
if awareness_options is UNSET:
self.op.channels_to_remove.append(awareness_channel)
else:
awareness_channel_data = AwarenessTuning.AWARENESS_CHANNEL_DATA.get(awareness_channel)
with ProtocolBufferRollback(self.op.channels_to_configure) as awareness_options_msg:
awareness_options_msg.name = awareness_channel
awareness_options_msg.type_name = awareness_channel.get_type_name()
if awareness_options is not DEFAULT:
awareness_options_msg.gate = awareness_options.gate
awareness_options_msg.gain = awareness_options.gain
awareness_options_msg.trigger_threshold_delta = awareness_options.threshold
if awareness_channel_data is not None:
awareness_options_msg.eval_mode = awareness_channel_data.evaluation_type
awareness_options_msg.limit = awareness_channel_data.limit
proximity_inner_radii = awareness_modifiers.get(self.PROXIMITY_INNER_RADIUS, ())
if proximity_inner_radii:
self.op.proximity_inner_radius = max(proximity_inner_radii)
proximity_outer_radii = awareness_modifiers.get(self.PROXIMITY_OUTER_RADIUS, ())
if proximity_outer_radii:
self.op.proximity_outer_radius = min(proximity_outer_radii)
def _build_journal_entry(self, obj, op):
object_name = None
proto_buff = protocolbuffers.DistributorOps_pb2.Operation()
if obj is None:
object_id = 0
manager_id = MGR_UNMANAGED
else:
object_id = obj.id
manager_id = obj.manager.id
mask_override = None
if manager_id == MGR_UNMANAGED:
mask_override = 0
if op._force_execution_on_tag:
mask_override = 0
elif op._primary_channel_mask_override is not None:
mask_override = op._primary_channel_mask_override
if mask_override is not None and mask_override != DEFAULT_MASK:
proto_buff.primary_channel_mask_override = mask_override
for channel in op._additional_channels:
with ProtocolBufferRollback(proto_buff.additional_channels) as additional_channel_msg:
additional_channel_msg.id.manager_id = channel[0]
additional_channel_msg.id.object_id = channel[1]
additional_channel_msg.mask = channel[2]
op.write(proto_buff)
entry = Journal.JournalEntry(object_id, proto_buff, manager_id, object_name)
return entry
