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 _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)
