def refresh_goals(self, completed_goal=None, debug_goal=None, debug_target=None, request_single_goal=False, request_single_delay=0, emotion_only=False): if completed_goal is not None: logger.debug('Whim completed for {}: {}', self._sim_info, completed_goal, owner='jjacobson') op = distributor.ops.SetWhimComplete(completed_goal.guid64) Distributor.instance().add_op(self._sim_info, op) if completed_goal.score > 0: self._sim_info.add_whim_bucks(completed_goal.score, SetWhimBucks.WHIM) self._remove_goal_from_current_order(completed_goal) completed_goal.unregister_for_on_goal_completed_callback( self._on_goal_completed) del self._realized_goals[completed_goal] completed_goal.decommision() if request_single_delay == 0 or debug_goal is not None: self.offer_goals(debug_goal=debug_goal, debug_target=debug_target, request_single_goal=request_single_goal, emotion_only=emotion_only) else: delay_alarm = alarms.add_alarm( self, create_time_span(minutes=request_single_delay), self._delayed_offer_goals, False) self.delay_alarm_handles.append(delay_alarm) self._send_goals_update()
def unslot_plumbbob(sim): reslot_op = ReslotPlumbbob(sim.id, 0, None, sims4.math.Vector3.ZERO(), balloon_offset=sims4.math.Vector3.ZERO()) Distributor.instance().add_op(sim, reslot_op)
def send_business_funds_update(self): if self.is_owner_household_active: funds_msg = Business_pb2.BusinessFundsUpdate() funds_msg.available_funds = self.funds.money funds_msg.zone_id = self.business_zone_id op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.BUSINESS_FUNDS_UPDATE, funds_msg) Distributor.instance().add_op_with_no_owner(op)
def focus_on_object_from_position(obj_position=None, camera_position=None, client=None): op = FocusCamera() op.set_position(camera_position) op.set_location(obj_position) Distributor.instance().add_op_with_no_owner(op)
def _distribute_business_open_status(self, is_open=True, open_time=0): open_msg = Business_pb2.BusinessIsOpenUpdate() open_msg.is_open = is_open open_msg.time_opened = open_time open_msg.zone_id = self.business_zone_id op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.BUSINESS_OPEN_UPDATE, open_msg) Distributor.instance().add_op_with_no_owner(op)
def reslot_plumbbob(sim, reslot_plumbbob): reslot_op = ReslotPlumbbob(sim.id, sim.id, reslot_plumbbob.bone_name, reslot_plumbbob.offset, balloon_offset=reslot_plumbbob.balloon_offset) Distributor.instance().add_op(sim, reslot_op)
def on_remove(self): # We override the on_remove function of the client so we can remove the stand-in client at the same time. # Only supports one multiplayer client at the moment, which has the id of 1000. if self.active_sim is not None: self._set_active_sim_without_field_distribution(None) if self._account is not None: self._account.unregister_client(self) for sim_info in self._selectable_sims: self.on_sim_removed_from_skewer(sim_info) self.selectable_sims.remove_watcher(self) distributor_instance = Distributor.instance() distributor_instance.remove_client(self) self._selectable_sims = None self.active = False if self.id != 1000: Distributor.instance().remove_client_from_id(1000) client_manager = services.client_manager() client = client_manager.get(1000) client_manager.remove(client)
def _send_daily_items_sold_update(self): if self.is_active_household_and_zone(): items_sold_msg = Business_pb2.BusinessDailyItemsSoldUpdate() items_sold_msg.zone_id = self.business_zone_id items_sold_msg.daily_items_sold = self.daily_items_sold op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.BUSINESS_DAILY_ITEMS_SOLD_UPDATE, items_sold_msg) Distributor.instance().add_op_with_no_owner(op)
def show_orgs_events_dialog(sim:RequiredTargetParam, _connection=None): sim_info = sim.get_target(manager=services.sim_info_manager()) if sim_info is None: sims4.commands.output('Sim with id {} is not found to show organizations events dialog.'.format(sim.target_id), _connection) return False op = AskAboutClubsDialog(sim_info.id, show_orgs=True) Distributor.instance().add_op_with_no_owner(op)
def handle_event(self, _, event, resolver): interaction = resolver.interaction if not interaction.visible: return sim_info = interaction.sim.sim_info if event == TestEvent.InteractionStart: club_service = services.get_club_service() (rule_status, _) = club_service.get_interaction_encouragement_status_and_rules_for_sim_info(sim_info, interaction.aop) if rule_status != ClubRuleEncouragementStatus.NO_EFFECT: self._interaction_rule_status[sim_info.sim_id][rule_status].add(interaction.id) if rule_status == ClubRuleEncouragementStatus.DISCOURAGED: rule_breaking_buff_op = self.owner.rule_breaking_buff sim_info.add_buff_from_op(rule_breaking_buff_op.buff_type, buff_reason=rule_breaking_buff_op.buff_reason) elif event == TestEvent.InteractionComplete: if sim_info.sim_id not in self._interaction_rule_status: return for interaction_set in self._interaction_rule_status[sim_info.sim_id].values(): interaction_set.discard(interaction.id) interaction_rule_status = self._interaction_rule_status.get(sim_info.sim_id) if interaction_rule_status is None: return if interaction_rule_status[ClubRuleEncouragementStatus.DISCOURAGED]: rule_status = ClubRuleEncouragementStatus.DISCOURAGED elif interaction_rule_status[ClubRuleEncouragementStatus.ENCOURAGED]: rule_status = ClubRuleEncouragementStatus.ENCOURAGED else: rule_status = ClubRuleEncouragementStatus.NO_EFFECT op = SendClubInteractionRuleUpdate(rule_status) Distributor.instance().add_op(sim_info, op)
def remove_sim_from_ensemble(self, sim): self._sims.remove(sim) if self.ensemble_autonomous_interactions: sim_info_utils.remove_super_affordance_commodity_flags(sim, self) if self.visible: op = UpdateEnsemble(self._guid, sim.id, False) Distributor.instance().add_op_with_no_owner(op)
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 _on_remove_sim_from_situation(self, sim): if not services.current_zone().is_zone_running: super()._on_remove_sim_from_situation(sim) return sim_job = self.get_current_job_for_sim(sim) services.get_zone_situation_manager().add_sim_to_auto_fill_blacklist( sim.id, sim_job=sim_job) (pet_sim_info, pet_owner_sim_info) = self._get_pet_and_owner_sim_infos() pet_sim_info.remove_linked_sim(pet_owner_sim_info.sim_id) pet_owner_sim_info.remove_linked_sim(pet_sim_info.sim_id) pet_owner = self.get_pet_owner() is_pet_owner = False if pet_owner is None else sim is pet_owner super()._on_remove_sim_from_situation(sim) business_manager = services.business_service( ).get_business_manager_for_zone() if business_manager is not None and is_pet_owner: business_manager.remove_customer( sim, review_business=self._should_leave_review) customer_msg = Business_pb2.BusinessCustomerUpdate() customer_msg.sim_id = pet_owner_sim_info.sim_id op = GenericProtocolBufferOp( DistributorOps_pb2.Operation.BUSINESS_CUSTOMER_REMOVE, customer_msg) Distributor.instance().add_op_with_no_owner(op)
def _send_skill_delete_message(self): if self.tracker.owner.is_npc: return skill_msg = Commodities_pb2.SkillDelete() skill_msg.skill_id = self.guid64 op = GenericProtocolBufferOp(Operation.SIM_SKILL_DELETE, skill_msg) Distributor.instance().add_op(self.tracker.owner, op)
def shutdown(self, finishing_type): if self._initiating_sim: stat_tracker = self._initiating_sim.get_tracker(self.interrogation_statistic) if stat_tracker.has_watcher(self._interrogation_callback): stat_tracker.remove_watcher(self._interrogation_callback) op = self._get_interrogation_op(InterrogationUpdateType.TYPE_STOP) Distributor.instance().add_op(self._initiating_sim, op) super().shutdown(finishing_type)
def _interrogation_statistic_callback(self, stat_type, old_value, new_value): if self.interrogation_statistic is not stat_type: return op = self._get_interrogation_op(InterrogationUpdateType.TYPE_UPDATE) Distributor.instance().add_op(self._initiating_sim, op) if self._initiating_sim is not None and self._target_sim is not None and self.interrogation_end_interaction_data.interrogation_statistic_threshold.compare(new_value): context = InteractionContext(self._initiating_sim, InteractionContext.SOURCE_SCRIPT, Priority.High) self._initiating_sim.push_super_affordance(self.interrogation_end_interaction_data.interrogation_end_interaction, self._target_sim, context)
def send_buff_update_msg(self, buff, equipped, change_rate=None, immediate=False): if not buff.visible: return if self.owner.valid_for_distribution and self.owner.is_sim and self.owner.is_selectable: buff_msg = self._create_buff_update_msg(buff, equipped, change_rate=change_rate) if gsi_handlers.buff_handlers.sim_buff_log_archiver.enabled: gsi_handlers.buff_handlers.archive_buff_message(buff_msg, equipped, change_rate) Distributor.instance().add_op(self.owner, GenericProtocolBufferOp(Operation.SIM_BUFF_UPDATE, buff_msg))
def end_ensemble(self): if self.ensemble_autonomous_interactions: for sim in self._sims: sim_info_utils.remove_super_affordance_commodity_flags(sim, self) self._sims.clear() if self.visible: op = EndEnsemble(self._guid) Distributor.instance().add_op_with_no_owner(op)
def send_icon_update_to_client(self): msg = Situations_pb2.SituationIconUpdate() msg.situation_id = self.id build_icon_info_msg(self.get_pet().get_icon_info_data(), None, msg.icon_info) msg.icon_info.control_id = ICON_CONTROL_ID op = distributor.ops.SituationIconUpdateOp(msg) Distributor.instance().add_op(self, op)
def _send_advertisement_update_message(self): msg = Business_pb2.BusinessAdvertisementUpdate() msg.zone_id = self._business_manager.business_zone_id msg.advertisement_chosen = self._advertising_type op = GenericProtocolBufferOp( DistributorOps_pb2.Operation.BUSINESS_ADVERTISEMENT_DATA_UPDATE, msg) Distributor.instance().add_op_with_no_owner(op)
def _send_interpolation_update(self, mid_season_op=False): season_service = services.season_service() season = season_service.season content = season_service.season_content op = SeasonInterpolationOp(season, content, mid_season_op) Distributor.instance().add_op_with_no_owner(op) if not mid_season_op: self._schedule_mid_season_interpolation_update()
def _send_goal_update_to_client(self, resolver=None, completed_goal=None): pet = self.get_pet() if pet is None: return sickness = pet.sim_info.current_sickness op = distributor.ops.SituationGoalUpdateOp( self._create_situation_goal_update_msg(pet, sickness, resolver)) Distributor.instance().add_op(self, op)
def distribute_owned_inventory_update_message(self, obj, owner): if obj.id not in self._objects: return False msg = self._get_inventory_update_message( UI_pb2.InventoryItemUpdate.TYPE_UPDATE, obj) if msg is not None: op = GenericProtocolBufferOp(Operation.INVENTORY_ITEM_UPDATE, msg) Distributor.instance().add_op(owner, op)
def distribute_inventory_stack_update_message(self, obj): if obj.id not in self._objects: return msg = self._get_inventory_update_message( UI_pb2.InventoryItemUpdate.TYPE_SET_STACK_OPTION, obj) if msg is not None: op = GenericProtocolBufferOp(Operation.INVENTORY_ITEM_UPDATE, msg) Distributor.instance().add_op_with_no_owner(op)
def _cleanup_gathering(self): club_service = services.get_club_service() if club_service is None: logger.error("Attempting to end a Gathering but the ClubService doesn't exist.") return op = EndClubGathering(self.associated_club.club_id) Distributor.instance().add_op_with_no_owner(op) club_service.on_gathering_ended(self)
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 send_data_to_client(self): zone = services.get_zone(self._zone_id, allow_uninstantiated_zones=True) if zone is None: logger.error('Trying to send the business data to client but the business manager {} has an invalid zone id.', self) return business_data_msg = Business_pb2.SetBusinessData() self.construct_business_message(business_data_msg) business_data_op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.SET_BUSINESS_DATA, business_data_msg) Distributor.instance().add_op_with_no_owner(business_data_op)
def add_sim_to_ensemble(self, sim): if sim in self._sims: return self._sims.add(sim) if self.ensemble_autonomous_interactions: sim_info_utils.apply_super_affordance_commodity_flags(sim, self, self.ensemble_autonomous_interactions) if self.visible: op = UpdateEnsemble(self._guid, sim.id, True) Distributor.instance().add_op_with_no_owner(op)
def _setter(inst, value): message = self._get_message(inst) ret = setter(inst, message, value, True) if inst.valid_for_distribution: op_message = SparseMessage(self._message_type()) setter(inst, op_message, value, False) op = self.get_op(inst, value=op_message._value) if op is not None: Distributor.instance().add_op(inst, op) return ret
def _on_add_picker_selected(self, dialog): tag_objs = dialog.get_result_tags() if not tag_objs: return num_tags = len(tag_objs) can_add_more = dialog.max_selectable.number_selectable - num_tags > 0 if can_add_more: can_add_more = len(dialog.picker_rows) > num_tags op = CommunityBoardAddPolicy(tag_objs, dialog.target_sim.sim_id, can_add_more) Distributor.instance().add_op_with_no_owner(op)
def get_household_display_info(lot_id, _connection=None): persistence_service = services.get_persistence_service() household_display_info = UI_pb2.HouseholdDisplayInfo() household_id = persistence_service.get_household_id_from_lot_id(lot_id) if household_id is None: household_id = 0 household = services.household_manager().get(household_id) if household is None: household_id = 0 else: household_display_info.at_home_sim_ids.extend(household.get_sims_at_home()) household_display_info.household_id = household_id household_display_info.lot_id = lot_id op = shared_messages.create_message_op(household_display_info, Consts_pb2.MSG_UI_HOUSEHOLD_DISPLAY_INFO) Distributor.instance().add_op_with_no_owner(op)
def send_reject_response(client, sim, context_handle, cancel_reason): reject_msg = protocols.ServerResponseFailed() reject_msg.handle = context_handle reject_msg.reason = cancel_reason distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.SIM_SERVER_RESPONSE_FAILED, reject_msg)) logger.debug(' sending reject msg')
def _send_destroy_message_to_client(self): msg = commodity_protocol.RelationshipDelete() msg.actor_sim_id = self._sim_id msg.target_id = self._target_sim_id op = GenericProtocolBufferOp(DistributorOps_pb2.Operation.SIM_RELATIONSHIP_DELETE, msg) distributor = Distributor.instance() distributor.add_op(self.find_sim_info(), op)
def unlock_save(self, lock_holder, send_event=True): if lock_holder in self._save_locks: self._save_locks.remove(lock_holder) if send_event: if not self.is_save_locked(): msg = UI_pb2.GameSaveLockUnlock() msg.is_locked = False distributor = Distributor.instance() distributor.add_event(MSG_GAME_SAVE_LOCK_UNLOCK, msg) else: new_lock_holder = self._save_locks[-1] msg = UI_pb2.GameSaveLockUnlock() msg.is_locked = True msg.lock_reason = new_lock_holder.get_lock_save_reason() distributor = Distributor.instance() distributor.add_event(MSG_GAME_SAVE_LOCK_UNLOCK, msg)
def _open_ui_panel_for_object(self, owner): msg = UI_pb2.OpenInventory() msg.object_id = owner.id msg.inventory_id = self._get_inventory_id() msg.inventory_type = self._get_inventory_ui_type() distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.OPEN_INVENTORY, msg))
def lock_save(self, lock_holder): self._save_locks.append(lock_holder) msg = UI_pb2.GameSaveLockUnlock() msg.is_locked = True msg.lock_reason = lock_holder.get_lock_save_reason() distributor = Distributor.instance() distributor.add_event(MSG_GAME_SAVE_LOCK_UNLOCK, msg)
def publish_shared_inventory_items(self): distributor = Distributor.instance() for (inventory_type, inventory_object) in self.inv_objs.items(): if inventory_type == InventoryType.HIDDEN: pass for (obj, message_op) in inventory_object.get_item_update_ops_gen(): distributor.add_op(obj, message_op) inventory_object.update_inventory_count()
def refresh_goals(self, completed_goal=None, debug_goal=None, debug_target=None, request_single_goal=False, request_single_delay=0, emotion_only=False): if completed_goal is not None: logger.debug('Whim completed for {}: {}', self._sim_info, completed_goal, owner='jjacobson') op = distributor.ops.SetWhimComplete(completed_goal.guid64) Distributor.instance().add_op(self._sim_info, op) if completed_goal.score > 0: self._sim_info.add_whim_bucks(completed_goal.score, SetWhimBucks.WHIM) self._remove_goal_from_current_order(completed_goal) completed_goal.unregister_for_on_goal_completed_callback(self._on_goal_completed) del self._realized_goals[completed_goal] completed_goal.decommision() if request_single_delay == 0 or debug_goal is not None: self.offer_goals(debug_goal=debug_goal, debug_target=debug_target, request_single_goal=request_single_goal, emotion_only=emotion_only) else: delay_alarm = alarms.add_alarm(self, create_time_span(minutes=request_single_delay), self._delayed_offer_goals, False) self.delay_alarm_handles.append(delay_alarm) self._send_goals_update()
def distribute_dialog(self, _, dialog_msg): distributor_inst = Distributor.instance() op = distributor.shared_messages.create_message_op(dialog_msg, Consts_pb2.MSG_SHOW_MAP_VIEW) owner = self.owner if owner is not None: distributor_inst.add_op(owner, op) else: distributor_inst.add_op_with_no_owner(op)
def distribute_dialog(self, dialog_type, dialog_msg): distributor = Distributor.instance() notification_op = GenericProtocolBufferOp(Operation.UI_NOTIFICATION_SHOW, dialog_msg) owner = self.owner if owner is not None: distributor.add_op(owner, notification_op) else: distributor.add_op_with_no_owner(notification_op)
def distribute(self): sim = self._sim if sim is not None and not sim.is_hidden(): balloon_op = AddBalloon(self, sim) distributor = Distributor.instance() distributor.add_op(sim, balloon_op) return True return False
def _send_objectives_update_to_client(self): owner = self.owner_sim_info if owner is None or owner.is_npc or owner.manager is None: return msg = Sims_pb2.GoalsStatusUpdate() if self._update_objectives_msg_for_client(msg): msg.sim_id = owner.id distributor = Distributor.instance() distributor.add_op(owner, GenericProtocolBufferOp(Operation.SIM_GOALS_STATUS_UPDATE, msg))
def _removed_ui_update(self, obj): msg = UI_pb2.InventoryItemUpdate() msg.type = UI_pb2.InventoryItemUpdate.TYPE_REMOVE msg.inventory_id = self._get_inventory_id() msg.inventory_type = self._get_inventory_ui_type() msg.object_id = obj.id msg.stack_id = obj.inventoryitem_component.get_stack_id() distributor = Distributor.instance() distributor.add_op(obj, GenericProtocolBufferOp(Operation.INVENTORY_ITEM_UPDATE, msg))
def on_add(self): if self._account is not None: self._account.register_client(self) for sim_info in self._selectable_sims: self.on_sim_added_to_skewer(sim_info) distributor = Distributor.instance() distributor.add_object(self) distributor.add_client(self) self.send_selectable_sims_update() self.selectable_sims.add_watcher(self, self.send_selectable_sims_update)
def send_live_drag_cancel(self, live_drag_object_id, live_drag_end_system=LiveDragLocation.INVALID): if gsi_handlers.live_drag_handlers.live_drag_archiver.enabled: gsi_handlers.live_drag_handlers.archive_live_drag('Cancel', 'Operation', LiveDragLocation.GAMEPLAY_SCRIPT, live_drag_end_system, live_drag_object_id=live_drag_object_id) op = distributor.ops.LiveDragCancel(live_drag_object_id, self._live_drag_start_system, live_drag_end_system) distributor_system = Distributor.instance() distributor_system.add_op_with_no_owner(op) if not self._live_drag_sell_dialog_active: self._live_drag_objects = [] self._live_drag_start_system = LiveDragLocation.INVALID self._live_drag_is_stack = False
def send_collection_msg(self, msg_type, collectable_id, household_id, obj_def_id, obj_id=None): msg = UI_pb2.CollectibleItemUpdate() msg.type = msg_type msg.collection_id = collectable_id msg.household_id = household_id if obj_id is not None: msg.object_id = obj_id msg.object_def_id = obj_def_id distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.SIM_COLLECTIBLE_ITEM_UPDATE, msg))
def _run_gen(self, timeline): play_audio_primative = self.target.get_component_managed_state_distributable('audio_state', self.affordance.audio_state_type) if play_audio_primative is not None: msg = Audio_pb2.SoundSkipToNext() msg.object_id = self.target.id msg.channel = play_audio_primative.channel distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.OBJECT_AUDIO_PLAYLIST_SKIP_TO_NEXT, msg)) return True yield None
def _run_interaction_gen(self, timeline): target = self.target r = g = b = sims4.color.MAX_INT_COLOR_VALUE color = target.get_light_color() intensity = target.get_user_intensity_overrides() target.set_light_dimmer_value(intensity) if color is not None: (r, g, b, _) = sims4.color.to_rgba_as_int(color) op = ShowLightColorUI(r, g, b, intensity, target.id, self._all_lights) distributor = Distributor.instance() distributor.add_op_with_no_owner(op)
def send_process_update(self, running_interaction, increment_turn=True): sim = self.crafter if sim is not None: if self.phase is None: op = distributor.ops.InteractionProgressUpdate(sim.sim_id, 1, 0, running_interaction.id) Distributor.instance().add_op(sim, op) return if not self.phase.is_visible: return if self.phase.progress_based: turns = self.get_turns_in_current_phase() if turns == 0: return progress = self.get_progress()/turns else: if increment_turn: pass progress = self._current_turn/self._total_turns op = distributor.ops.InteractionProgressUpdate(sim.sim_id, progress, 0, running_interaction.id) Distributor.instance().add_op(sim, op)
def send_lot_display_info(self): persistence = services.get_persistence_service() lot_owner_data = persistence.get_lot_proto_buff(self.lot_id) lot_name = None if lot_owner_data is not None: zone_data = persistence.get_zone_proto_buff(lot_owner_data.zone_instance_id) if zone_data is not None: lot_name = zone_data.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 op = distributor.shared_messages.create_message_op(msg, Consts_pb2.MSG_UI_LOT_DISPLAY_INFO) Distributor.instance().add_op_with_no_owner(op)
def save_game_gen(self, timeline, save_game_data, send_save_message=True, check_cooldown=False): (result_code, failure_reason) = yield self._save_game_gen(timeline, save_game_data, check_cooldown=check_cooldown) if send_save_message: msg = UI_pb2.GameSaveComplete() msg.return_status = result_code msg.save_cooldown = self._get_cooldown() if failure_reason is not None: msg.failure_reason = failure_reason msg.slot_id = save_game_data.slot_id distributor = Distributor.instance() distributor.add_event(MSG_GAME_SAVE_COMPLETE, msg) return result_code
def _distribute(self): op = protocolbuffers.DistributorOps_pb2.SetCareers() with ProtocolBufferRollback(op.careers) as career_op: history = self._get_career_history() career_op.career_uid = self._career_uid career_op.career_level = history.career_level career_op.career_track = history.track_uid career_op.user_career_level = history.user_level career_op.is_retired = True distributor = Distributor.instance() if distributor is not None: distributor.add_op(self._sim_info, GenericProtocolBufferOp(Operation.SET_CAREER, career_op))
def on_remove(self): if self.active_sim is not None: self._set_active_sim_without_field_distribution(None) if self._account is not None: self._account.unregister_client(self) for sim_info in self._selectable_sims: self.on_sim_removed_from_skewer(sim_info, update_relationship_tracker=False) self.selectable_sims.remove_watcher(self) distributor = Distributor.instance() distributor.remove_client(self) self._selectable_sims = None self.active = False
def deserialize(client=None): global _sim_id, _target_position, _camera_position, _follow_mode, _zone_id save_slot_data_msg = services.get_persistence_service( ).get_save_slot_proto_buff() if save_slot_data_msg is not None and save_slot_data_msg.HasField( 'gameplay_data'): gameplay_data = save_slot_data_msg.gameplay_data if gameplay_data.HasField('camera_data'): camera_data = save_slot_data_msg.gameplay_data.camera_data if camera_data.HasField('target_id'): _sim_id = camera_data.target_id _target_position = camera_data.target_position _camera_position = camera_data.camera_position _follow_mode = camera_data.follow_mode _zone_id = camera_data.zone_id if camera_data.HasField( 'household_id') and services.active_lot( ).owner_household_id != camera_data.household_id: return False if _follow_mode and services.sim_info_manager().get( _sim_id) is None: _sim_id = None _target_position = None _camera_position = None _follow_mode = None _zone_id = None return False if _zone_id == sims4.zone_utils.get_zone_id(): op = FocusCamera(id=_sim_id, follow_mode=_follow_mode) op.set_location(_target_position) op.set_position(_camera_position) Distributor.instance().add_op_with_no_owner(op) return True _sim_id = None _target_position = None _camera_position = None _follow_mode = None _zone_id = None return False
def send_satisfaction_reward_list(self): msg = Sims_pb2.SatisfactionRewards() for (reward, data) in self.SATISFACTION_STORE_ITEMS.items(): reward_msg = Sims_pb2.SatisfactionReward() reward_msg.reward_id = reward.guid64 reward_msg.cost = data.cost reward_msg.affordable = True if data.cost <= self._sim_info.get_whim_bucks() else False reward_msg.available = reward.is_valid(self._sim_info) reward_msg.type = data.award_type msg.rewards.append(reward_msg) msg.sim_id = self._sim_info.id distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.SIM_SATISFACTION_REWARDS, msg))
def trigger(_): msg = Social_pb2.LifeEventMessage() msg.type = life_event_category participant_ids = [] for participant_types in participants: participant = interaction.get_participant(participant_types) if participant is None: participant_ids.append(0) else: participant_ids.append(participant.id) msg.sim_ids.extend(participant_ids) distributor = Distributor.instance() distributor.add_op_with_no_owner(GenericProtocolBufferOp(Operation.LIFE_EVENT_SEND, msg))
def _change_level(self, delta): new_level = self._level + delta num_career_levels = len(self._current_track.career_levels) if new_level < 0: return False if new_level >= num_career_levels: if self.current_track_tuning.branches: sim_info = self._sim_info if sim_info.is_selectable and sim_info.valid_for_distribution: if services.current_zone().ui_dialog_service.auto_respond: self.set_new_career_track(self.current_track_tuning.branches[0].guid64) return False msg = self.get_select_career_track_pb(sim_info, self, self.current_track_tuning.branches) Distributor.instance().add_op(sim_info, GenericProtocolBufferOp(Operation.SELECT_CAREER_UI, msg)) return False self.career_stop() self._level = new_level self._sim_info.career_tracker.update_history(self) self._reset_career_objectives(self._current_track, new_level) self.career_start() self.resend_career_data() self.resend_at_work_info() return True
def send_interaction_outcome_msg(sim, outcome_success, outcome_result_message, immediate=False): logger.debug('send_interaction_outcome_msg({})', sim.id) msg = Sims_pb2.InteractionOutcome() msg.sim_id = sim.id if outcome_success: msg.result = Sims_pb2.InteractionOutcome.POSITIVE else: msg.result = Sims_pb2.InteractionOutcome.NEGATIVE if outcome_result_message is not None: msg.display_message = outcome_result_message logger.debug(' SENDING') distributor = Distributor.instance() op = MessageOp(msg, MSG_SIM_INTERACTION_OUTCOME, immediate) distributor.add_op(sim, op)