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