def sell_response(dialog): if not dialog.accepted: return value = int(self.get_live_drag_object_value(live_drag_object, self._live_drag_is_stack)) live_drag_component.cancel_live_dragging(should_reset=False) object_tags = set() if self._live_drag_is_stack: (_, stack_items) = self._get_stack_items_from_drag_object(live_drag_object, remove=True, is_stack=True) for item in stack_items: item.current_value = 0 item.set_stack_count(0) object_tags.update(item.get_tags()) item.destroy(source=item, cause='Selling stack of live drag objects.') else: object_tags.update(live_drag_object.get_tags()) if live_drag_object.is_in_inventory(): self.remove_drag_object_and_get_next_item(live_drag_object) else: live_drag_object.remove_from_client() object_tags = frozenset(object_tags) live_drag_object.current_value = 0 live_drag_object.destroy(source=live_drag_object, cause='Selling live drag object.') services.active_household().funds.add(value, Consts_pb2.TELEMETRY_OBJECT_SELL, self.active_sim, tags=object_tags) self._live_drag_objects = [] self._live_drag_start_system = LiveDragLocation.INVALID self._live_drag_is_stack = False self._live_drag_sell_dialog_active = False
def _award_insurance_money(self): client = services.client_manager().get_first_client() active_sim = client.active_sim if self._insurance_value > 0 and active_sim is not None: services.active_household().funds.add(self._insurance_value, Consts_pb2.TELEMETRY_INTERACTION_COST, None) dialog = self.FIRE_INSURANCE_CLAIM_NOTIFICATION(active_sim, SingleSimResolver(active_sim)) dialog.show_dialog(additional_tokens=(self._insurance_value,)) self._insurance_value = 0
def on_loading_screen_animation_finished(self): logger.debug('on_loading_screen_animation_finished') services.game_clock_service().restore_saved_clock_speed() services.sim_info_manager().on_loading_screen_animation_finished() services.get_event_manager().process_events_for_household( test_events.TestEvent.SimTravel, services.active_household(), zone_id=self.id)
def get_active_household() -> Union[Household, None]: """get_active_household() Retrieve the Household of the Active Sim. :return: The Household of the Active Sim or None if no household is found. :rtype: Union[Household, None] """ return services.active_household()
def clear_debt(self): if self.debt_source == DebtSource.SCHOOL_LOAN: host_sim_info = services.sim_info_manager().get( self._guest_list.host_sim_id) statistic = host_sim_info.get_statistic( LoanTunables.DEBT_STATISTIC, add=False) if statistic is None: return else: statistic.set_value(0) elif self.debt_source == DebtSource.BILLS: services.active_household().bills_manager.pay_bill(clear_bill=True) else: logger.error( 'Attempting to use a debt source {} that is not handled', self.debt_source, owner='jjacobson') return
def _lifestyle_brand_alarm_tick(self, *_): household = services.active_household() if household is None: return for sim_info in household.sim_info_gen(): tracker = sim_info.lifestyle_brand_tracker if tracker is None: continue tracker.payout_lifestyle_brand()
def _royalty_alarm_tick(self, *_): household = services.active_household() if household is None: return for sim_info in household.sim_info_gen(): tracker = sim_info.royalty_tracker if tracker is None: continue tracker.update_royalties_and_get_paid()
def end_vacation(self): active_household = services.active_household() current_zone_id = services.current_zone_id() current_region_id = get_region_description_id_from_zone_id( current_zone_id) rental_region_id = get_region_description_id_from_zone_id( self._zone_id) if current_region_id != rental_region_id or not active_household.any_member_belong_to_travel_group_id( self.id): at_home = current_zone_id == active_household.home_zone_id for sim_info in self: if active_household.id == sim_info.household_id and at_home: if not sim_info.is_instanced( allow_hidden_flags=ALL_HIDDEN_REASONS): SimSpawner.spawn_sim(sim_info) if sim_info.is_instanced( allow_hidden_flags=ALL_HIDDEN_REASONS): services.get_zone_situation_manager( ).make_sim_leave_now_must_run( sim_info.get_sim_instance( allow_hidden_flags=ALL_HIDDEN_REASONS)) else: sim_info.inject_into_inactive_zone( sim_info.household.home_zone_id) elif sim_info.is_instanced( allow_hidden_flags=ALL_HIDDEN_REASONS): services.get_zone_situation_manager( ).make_sim_leave_now_must_run( sim_info.get_sim_instance( allow_hidden_flags=ALL_HIDDEN_REASONS)) else: sim_info.inject_into_inactive_zone( sim_info.household.home_zone_id) services.travel_group_manager( ).destroy_travel_group_and_release_zone(self, return_objects=True) return for instanced_sim in active_household.instanced_sims_gen(): instanced_sim.queue.cancel_all() travel_info = InteractionOps_pb2.TravelSimsToZone() travel_info.zone_id = active_household.home_zone_id active_sims_on_zone = [ active_sim_info for active_sim_info in active_household if active_sim_info.zone_id == current_zone_id ] for sim_info in itertools.chain(self, active_sims_on_zone): if active_household.id == sim_info.household_id: if sim_info.sim_id not in travel_info.sim_ids: travel_info.sim_ids.append(sim_info.sim_id) else: sim_info.inject_into_inactive_zone( sim_info.household.home_zone_id) distributor.system.Distributor.instance().add_event( Consts_pb2.MSG_TRAVEL_SIMS_TO_ZONE, travel_info) services.game_clock_service().set_clock_speed(ClockSpeedMode.PAUSED) services.travel_group_manager().destroy_travel_group_and_release_zone( self)
def return_lost_objects(self): returned_objects = defaultdict(list) current_zone = services.current_zone() current_zone_id = services.current_zone_id() current_open_street_id = current_zone.open_street_id active_household = services.active_household() for locator in list(self._object_locators): if locator.zone_id != current_zone_id: if locator.open_street_id != current_open_street_id: elapsed_time = services.time_service( ).sim_now - locator.time_stamp if elapsed_time.in_minutes() < locator.time_before_lost: continue if locator.object_data is None: self.remove_object(locator.object_id) else: (obj_returned, owner) = self._return_lost_object(locator) if obj_returned is not None: if owner is not None: if isinstance(owner, int): if owner == active_household.id: returned_objects[owner].append( obj_returned) if owner.household is active_household: returned_objects[owner].append( obj_returned) elif owner.household is active_household: returned_objects[owner].append( obj_returned) if not returned_objects: return returned_objects_string = None household_manager = services.household_manager() for (owner, objects) in returned_objects.items(): if isinstance(owner, int): household = household_manager.get(owner) header = ObjectLostAndFoundService.FAMILY_NAME_HEADER( household.name) next_string = LocalizationHelperTuning.get_bulleted_list( header, *(LocalizationHelperTuning.get_object_name(obj) for obj in objects)) else: next_string = LocalizationHelperTuning.get_bulleted_list( LocalizationHelperTuning.get_sim_name(owner), *(LocalizationHelperTuning.get_object_name(obj) for obj in objects)) if returned_objects_string is None: returned_objects_string = next_string else: returned_objects_string = LocalizationHelperTuning.NEW_LINE_LIST_STRUCTURE( returned_objects_string, next_string) dialog = ObjectLostAndFoundService.OBJECTS_RETURN_MESSAGE_DIALOG( services.active_sim_info()) dialog.show_dialog(additional_tokens=(returned_objects_string, ))
def extend_vacation(self, duration_days, cost=0): extension = clock.interval_in_sim_days(duration_days) self.end_timestamp = self.end_timestamp + extension self.setup_rented_zone_alarms() services.active_household().funds.try_remove( cost, reason=Consts_pb2.FUNDS_MONEY_VACATION, sim=services.get_active_sim()) leader_sim_info = services.active_sim_info() if leader_sim_info not in self: leader_sim_info = self._sim_infos[0] with telemetry_helper.begin_hook(travel_group_telemetry_writer, TELEMETRY_HOOK_TRAVEL_GROUP_EXTEND, sim_info=leader_sim_info) as hook: hook.write_int(TELEMETRY_TRAVEL_GROUP_ID, self.id) hook.write_int(TELEMETRY_TRAVEL_GROUP_ZONE_ID, self.zone_id) hook.write_int(TELEMETRY_TRAVEL_GROUP_SIZE, len(self)) hook.write_int(TELEMETRY_TRAVEL_GROUP_DURATION, int(self.duration_time_span.in_minutes()))
def on_enter(self): super().on_enter() for sim_info in services.sim_info_manager().values(): if sim_info.do_first_sim_info_load_fixups: sim_info.apply_fixup_actions( SimInfoFixupActionTiming.ON_FIRST_SIMINFO_LOAD) for sim_info in services.active_household(): sim_info.apply_fixup_actions( SimInfoFixupActionTiming.ON_ADDED_TO_ACTIVE_HOUSEHOLD) return _ZoneSpinUpStateResult.DONE
def on_activate(self, reader): super().on_activate(reader) if self.owner.neighor_saved_me_buff: if self.owner._fire_brigade_put_out_fire: for sim_info in services.active_household().instanced_sims_gen(): sim_info.add_buff_from_op(self.owner.neighor_saved_me_buff.buff_type, self.owner.neighor_saved_me_buff.buff_reason) if self.owner.visit_afterwards: for fire_brigade_volunteer in self.owner.get_fire_brigade_sim_infos(): services.get_zone_situation_manager().create_visit_situation(fire_brigade_volunteer) self.owner._self_destruct()
def get_value_with_markup(self, value) -> int: markup_multiplier = self.markup_multiplier if self.owner_household_id is not None: tracker = services.business_service().get_business_tracker_for_household(self.owner_household_id, self.business_type) markup_multiplier += tracker.additional_markup_multiplier else: active_household = services.active_household() if active_household is not None: markup_multiplier *= active_household.holiday_tracker.get_active_holiday_business_price_multiplier(self.business_type) return int(value*markup_multiplier)
def _on_set_sim_role_state(self, sim, *args, **kwargs): super()._on_set_sim_role_state(sim, *args, **kwargs) relationship_tracker = sim.sim_info.relationship_tracker for sim_info in services.active_household(): if relationship_tracker.has_bit( sim_info.sim_id, RelationshipGlobalTuning. NEIGHBOR_GIVEN_KEY_RELATIONSHIP_BIT): self._change_state(self.owner._hangout_state()) return self._change_state(self.owner._knock_on_door_state())
def on_add(self, *_, **__): self.owner.hover_tip = ui_protocols.UiObjectMetadata.HOVER_TIP_GARDENING active_household = services.active_household() if active_household is not None and services.current_zone_id( ) == active_household.zone_id and self.owner.is_on_active_lot(): if hasattr(self, 'fruit_name'): return rebate_manager = active_household.rebate_manager rebate_manager.add_rebate_for_object( self.owner.id, RebateCategoryEnum.GAMEPLAY_OBJECT)
def is_ungreeted_sim_disallowed(self): zone_id = services.current_zone_id() active_household = services.active_household() if active_household is not None and active_household.home_zone_id == zone_id: return False else: plex_service = services.get_plex_service() if plex_service.get_plex_building_type(zone_id) != PlexBuildingType.PENTHOUSE_PLEX: return False return True
def trigger_sickness_distribution(self): active_household = services.active_household() for sim_info in active_household: if sim_info.sickness_tracker is None: continue resolver = SingleSimResolver(sim_info) if not self._should_sim_become_sick(resolver): continue sickness = self._choose_sickness_for_sim( resolver, criteria_func=lambda s: not s.distribute_manually) sickness.apply_to_sim_info(sim_info)
def autopay_bills(enable: bool = None, _connection=NO_CONTEXT): household = services.active_household() if household is None: sims4.commands.output('No active household.', _connection) return bills_manager = household.bills_manager autopay_bills = enable if enable is not None else not bills_manager.autopay_bills bills_manager.autopay_bills = autopay_bills sims4.commands.output( 'Autopay Bills for household {} set to {}.'.format( household, autopay_bills), _connection)
def _on_set_sim_job(self, sim, job_type): super()._on_set_sim_job(sim, job_type) if self.support_given_keys: relationship_tracker = sim.sim_info.relationship_tracker for sim_info in services.active_household(): if relationship_tracker.has_bit( sim_info.sim_id, RelationshipGlobalTuning. NEIGHBOR_GIVEN_KEY_RELATIONSHIP_BIT): services.current_zone( ).venue_service.active_venue.summon_npcs( (sim.sim_info, ), self.SUMMONING_PURPOSE)
def create_welcome_wagon(self): situation_manager = services.get_zone_situation_manager() if not situation_manager.is_user_facing_situation_running(): situation_manager.create_situation( self._welcome_wagon_situation, guest_list=self._guest_list.clone(), user_facing=True, scoring_enabled=False) active_household = services.active_household() active_household.needs_welcome_wagon = False self._self_destruct()
def scheduled_start_action(self, scheduler, alarm_data, extra_data): if self.chance and random.random() < self.chance: return household_id = services.active_household().id self.start_action(household_id) blackout_end_time = alarm_data[1] - alarm_data[0] self._stop_schedule_entry = alarms.add_alarm( self, blackout_end_time, lambda _: self.scheduled_stop_action(household_id), cross_zone=True)
def _send_update_message(self): household = services.active_household() if household is None: return street = world.street.get_street_instance_from_world_id( household.get_home_world_id()) if street is None: return provider = self.get_provider(street) if provider is None: return provider.send_update_message()
def _handle_curfew_message_callback(self, handle): active_lot = services.active_lot() if active_lot.lot_id != services.active_household_lot_id(): from_sim = None for sim_info in services.active_household(): if sim_info.is_young_adult_or_older: if not sim_info.is_instanced(): from_sim = sim_info break if from_sim is None: return for sim_info in services.active_household(): if sim_info.get_sim_instance() is None: continue resolver = DoubleSimResolver(sim_info, from_sim) if not CurfewService.CURFEW_WARNING_SIM_TESTS.run_tests( resolver): continue dialog = self.CURFEW_WARNING_TEXT_MESSAGE_DIALOG( sim_info, target_sim_id=from_sim.id, resolver=resolver) dialog.show_dialog()
def perform_auto_pick(cls, inst, choices): household = services.active_household() if household is None: return sim_ids = tuple(sim_info.id for sim_info in household.sim_info_gen()) obj_rel_tuples_list = [] for choice in choices: obj_rel_tuples_list.extend( cls._get_obj_rel_tuples_for_sims(choice, sim_ids)) if not obj_rel_tuples_list: return return max(obj_rel_tuples_list, key=operator.itemgetter(1))[0]
def timer_expired(self): for sim_info in services.active_household(): resolver = DoubleSimResolver(sim_info, self.owner._neighbor_sim.sim_info) for loot_action in self._early_exit_loot: loot_action.apply_to_resolver(resolver) resolver = DoubleSimResolver(services.active_sim_info(), self.owner._neighbor_sim.sim_info) early_exit_notification = self._early_exit_notification( services.active_sim_info(), resolver=resolver) early_exit_notification.show_dialog() self.owner._self_destruct()
def on_loading_screen_animation_finished(self): household = services.active_household() plex_service = services.get_plex_service() if household is not None and not household.has_home_zone_been_active( ) and plex_service.is_zone_an_apartment( household.home_zone_id, consider_penthouse_an_apartment=False): active_sim = services.get_active_sim() landlord_sim_info = self.get_landlord_sim_info() if active_sim is not None and landlord_sim_info is not None: dialog = LandlordTuning.LANDLORD_FIRST_PLAY_RENT_REMINDER_NOTIFICATION( active_sim) dialog.show_dialog(icon_override=IconInfoData( obj_instance=landlord_sim_info))
def payout_rebates(household_id: int = None, _connection=None): if household_id is None: household = services.active_household() else: household_manager = services.household_manager() household = household_manager.get(household_id) if household is None: return False rebate_manager = household.rebate_manager if rebate_manager is None: return False rebate_manager.payout_rebates() return True
def get_filter_results_for_job(cls): active_sim_info = services.active_sim_info() neighbor_results = services.sim_filter_service().submit_filter( cls.neighbor_job_and_default_role_state.job.filter, callback=None, requesting_sim_info=active_sim_info, allow_yielding=False, blacklist_sim_ids={ sim_info.sim_id for sim_info in services.active_household() }, gsi_source_fn=cls.get_sim_filter_gsi_name) return neighbor_results
def get_ambient_walkby_situation(cls, sim_slots_available): lot_id = services.active_lot_id() def can_start_situation(situation): if services.game_clock_service().clock_speed == ClockSpeedMode.SUPER_SPEED3 and not situation.allowed_in_super_speed_3: return False return situation.can_start_walkby(lot_id, sim_slots_available) household = services.active_household() additional_walkbys = [] if household is not None: additional_walkbys.extend(household.holiday_tracker.get_additional_holiday_walkbys(predicate=can_start_situation)) return cls.walkby_desire_by_day_of_week.get_situation_and_params(predicate=can_start_situation, additional_situations=additional_walkbys)[0]
def force_bills_due(_connection=None): household = services.active_household() if household is None: sims4.commands.output('No active household.', _connection) return bills_manager = household.bills_manager if bills_manager.current_payment_owed is None: previous_send_notification = bills_manager.bill_notifications_enabled bills_manager.bill_notifications_enabled = False bills_manager.allow_bill_delivery() if bills_manager.current_payment_owed is not None: bills_manager.trigger_bill_notifications_from_delivery() bills_manager.bill_notifications_enabled = previous_send_notification
def get_random_target(self): object_manager = services.object_manager() if self.target_filter_tags is not None: found_objects = object_manager.get_objects_matching_tags( self.target_filter_tags, match_any=True) if len(found_objects) > 0: random_object = random.choice(list(found_objects)) return random_object return else: household_sims = services.active_household().instanced_sims_gen() random_sim = random.choice(list(household_sims)) return random_sim
def create_career_event_situations_during_zone_spin_up(self): try: active_household = services.active_household() if active_household is None: return current_zone_id = services.current_zone_id() for sim_info in active_household: if sim_info.zone_id == current_zone_id: career = sim_info.career_tracker.career_currently_within_hours if career is not None: career.create_career_event_situations_during_zone_spin_up() except: logger.exception('Exception raised while trying to restore career event.', owner='tingyul')
def _test(self, resolver, skip_run_tests=False): homelot_id = services.active_household().home_zone_id if self.homelot_only and homelot_id != services.current_zone_id(): return TestResult( False, 'Cannot run because the current zone is not the home lot.') if self.host_sim_participant is not None: host_sim_info = self._get_resolver().get_participant( self.host_sim_participant) if host_sim_info is None: return TestResult( False, 'Cannot run because there is no host sim info.') return super()._test(resolver, skip_run_tests=skip_run_tests)
def save_current_houshold(slot_id:int=0, slot_name='Unnamed', _connection=None): output = sims4.commands.Output(_connection) try: sim_info.save_active_household_command_start() save_slot_data_msg = services.get_persistence_service().get_save_slot_proto_buff() save_slot_data_msg.slot_id = slot_id active_household = services.active_household() if active_household is not None: save_slot_data_msg.active_household_id = active_household.id sims4.core_services.service_manager.save_all_services(None, persistence_error_types.ErrorCodes.CORE_SERICES_SAVE_FAILED, save_slot_data=save_slot_data_msg) save_game_buffer = services.get_persistence_service().get_save_game_data_proto() persistence_module.run_persistence_operation(persistence_module.PersistenceOpType.kPersistenceOpSaveHousehold, save_game_buffer, 0, None) except Exception as e: output('Exception thrown while executing command persistence.save_active_household.\n{}'.format(e)) output('No household file generated. Please address all the exceptions.') raise finally: sim_info.save_active_household_command_stop() output('Exported active household to T:\\InGame\\Households\\{}.household'.format(active_household.name)) return 1
def on_added_to_inventory(self): household = services.active_household() if household is not None: household.collection_tracker.check_add_collection_item(household, self.owner.id, self.owner.definition.id)