def set_outfit_setting(self, setting, distribute=True): if self.outfit_setting != ClubOutfitSetting.NO_OUTFIT and setting == ClubOutfitSetting.NO_OUTFIT: club_service = services.get_club_service() if club_service is not None: gathering = club_service.clubs_to_gatherings_map.get(self) if gathering is not None: gathering.remove_all_club_outfits() self.outfit_setting = setting if distribute: services.get_club_service().distribute_club_update((self, ))
def validate_club_hangout(self): is_valid = True if self.hangout_setting == ClubHangoutSetting.HANGOUT_LOT: if not self.is_zone_valid_for_gathering(self.hangout_zone_id): is_valid = False elif self.hangout_setting == ClubHangoutSetting.HANGOUT_VENUE: if not self.hangout_venue.allowed_for_clubs: is_valid = False if not is_valid: self.hangout_setting = ClubHangoutSetting.HANGOUT_NONE services.get_club_service().distribute_club_update((self, )) self._validate_club_gathering_location()
def on_remove(self, from_stop=False): for member in list(self.members): self.remove_member(member, distribute=False, can_reassign_leader=False, from_stop=from_stop) for criteria in list(self.membership_criteria): self.remove_membership_criteria(criteria) for rule in list(self.rules): self.remove_rule(rule) services.get_club_service().update_affordance_cache() for drama_node_id in self.club_joined_drama_node_ids: services.drama_scheduler_service().cancel_scheduled_node( drama_node_id) self.club_joined_drama_node_ids.clear()
def on_update(self): super().on_update() if not services.sim_spawner_service().batch_spawning_complete: return _ZoneSpinUpStateResult.WAITING client = services.client_manager().get_first_client() services.sim_info_manager().on_spawn_sim_for_zone_spin_up_completed( client) services.venue_service().get_zone_director( ).on_spawn_sim_for_zone_spin_up_completed() services.current_zone( ).venue_service.handle_active_lot_changing_edge_cases() services.get_zone_situation_manager( ).on_all_sims_spawned_during_zone_spin_up() club_service = services.get_club_service() if club_service is not None: club_service.on_finish_waiting_for_sim_spawner_service() else: current_zone_id = services.current_zone_id() household = services.active_household() if household.home_zone_id != current_zone_id: sim_info_manager = services.sim_info_manager() traveled_sims = sim_info_manager.get_traveled_to_zone_sim_infos( ) if len(traveled_sims) > 1: services.ensemble_service( ).create_travel_ensemble_if_neccessary(traveled_sims) services.ensemble_service().on_all_sims_spawned_during_zone_spin_up() return _ZoneSpinUpStateResult.DONE
def get_default_selection_data(actor_sim, filter_list): default_selection_data = [] club_service = services.get_club_service() ensemble_service = services.ensemble_service() gathering = None ensemble = None if club_service is not None: gathering = club_service.sims_to_gatherings_map.get(actor_sim) if ensemble_service is not None: ensembles = ensemble_service.get_all_ensembles_for_sim(actor_sim) familiar_tracker = actor_sim.sim_info.familiar_tracker active_familiar_sim_id = None if familiar_tracker is not None: active_familiar_sim_id = familiar_tracker.active_familiar_id_pet_id for item in filter_list: sim_info = item.sim_info if sim_info.sim_id == active_familiar_sim_id: default_selection_data.append((sim_info, True)) else: sim = sim_info.get_sim_instance() if sim is not None and (gathering and club_service.sims_to_gatherings_map.get(sim) is gathering or ensembles and any(sim in ensemble for ensemble in ensembles)): default_selection_data.append((sim_info, True)) else: default_selection_data.append((sim_info, False)) default_selection_data.sort(key=operator.itemgetter(1), reverse=True) return default_selection_data
def on_enter(self): super().on_enter() zone = services.current_zone() zone.venue_service.build_buy_edit_mode = True services.household_manager().load_households() zone.on_households_and_sim_infos_loaded() client = zone.zone_spin_up_service._client_connect_data.client club_service = services.get_club_service() if club_service is not None: club_service.on_all_households_and_sim_infos_loaded(client) relationship_service = services.relationship_service() if relationship_service is not None: relationship_service.on_all_households_and_sim_infos_loaded(client) roommate_service = services.get_roommate_service() if roommate_service is not None: roommate_service.initialize_editmode_roommates() situation_manager = services.get_zone_situation_manager() situation_manager.spin_up_for_edit_mode() object_manager = services.object_manager() water_terrain_object_cache = object_manager.water_terrain_object_cache build_buy.register_build_buy_exit_callback( water_terrain_object_cache.refresh) conditional_layer_service = services.conditional_layer_service() conditional_layer_service.on_zone_load(editmode=True) for obj in object_manager.values(): footprint_component = obj.get_component(FOOTPRINT_COMPONENT) if footprint_component is not None: footprint_component.on_finalize_load() services.game_clock_service().restore_saved_clock_speed() return _ZoneSpinUpStateResult.DONE
def __init__(self, seed): super().__init__(seed) self.associated_club = None self._current_gathering_buff = None self._current_gathering_vibe = None self._sim_gathering_time_checks = {} self._can_disband = False self._initial_disband_timer_handle = None self._rewards_timer = None self._time_tracker_timer = None self._validity_household_id_override = None reader = self._seed.custom_init_params_reader if reader is not None: start_source = reader.read_uint64(ClubGatheringKeys.START_SOURCE, None) disband_ticks = reader.read_uint64(ClubGatheringKeys.DISBAND_TICKS, 0) self._validity_household_id_override = reader.read_uint64(ClubGatheringKeys.HOUSEHOLD_ID_OVERRIDE, None) associated_club_id = reader.read_uint64(ClubGatheringKeys.ASSOCIATED_CLUB_ID, None) if associated_club_id is not None: club_service = services.get_club_service() associated_club = club_service.get_club_by_id(associated_club_id) self.initialize_gathering(associated_club, disband_ticks=disband_ticks, start_source=start_source) current_gathering_buff_guid = reader.read_uint64(ClubGatheringKeys.GATHERING_BUFF, 0) self._current_gathering_buff = services.get_instance_manager(sims4.resources.Types.BUFF).get(current_gathering_buff_guid) vibe = reader.read_uint64(ClubGatheringKeys.GATHERING_VIBE, self._default_gathering_vibe) self.set_club_vibe(vibe)
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 generate_club_info_data(): club_service = services.get_club_service() if club_service is None: return sim_info_manager = services.sim_info_manager() club_info = [] for club in club_service.clubs: if club.hangout_setting == ClubHangoutSetting.HANGOUT_VENUE: club_hangout_str = 'Venue: {}'.format(str(club.hangout_venue)) elif club.hangout_setting == ClubHangoutSetting.HANGOUT_LOT: club_hangout_str = 'Zone: {}'.format(club.hangout_zone_id) else: club_hangout_str = 'None' entry = { 'name': str(club), 'club_id': str(club.club_id), 'hangout': club_hangout_str, 'associated_color': str(club.associated_color) if club.associated_color else 'None', 'uniform_male_child': str(bool(club.uniform_male_child)), 'uniform_female_child': str(bool(club.uniform_female_child)), 'uniform_male_adult': str(bool(club.uniform_male_adult)), 'uniform_female_adult': str(bool(club.uniform_female_adult)) } members_info = [] entry['club_members'] = members_info for sim in club.members: group_members_entry = { 'sim_id': str(sim.id), 'sim_name': sim.full_name, 'is_leader': str(sim is club.leader) } members_info.append(group_members_entry) entry['club_recent_members'] = [{ 'sim_id': str(sim_id), 'sim_name': str(sim_info_manager.get(sim_id)) } for sim_id in club._recent_member_ids] rules_info = [] entry['club_rules'] = rules_info if club.rules: for rule in club.rules: rules_entry = {'rule': str(rule)} rules_info.append(rules_entry) criteria_info = [] entry['membership_criteria'] = criteria_info if club.membership_criteria: for criteria in club.membership_criteria: criteria_entry = {'criteria': str(criteria)} criteria_info.append(criteria_entry) club_info.append(entry) return club_info
def _setup(self, *args, gsi_data=None, **kwargs): result = super()._setup(*args, gsi_data=gsi_data, **kwargs) if not result: return result club_service = services.get_club_service() if club_service is None: if gsi_data is not None: gsi_data.rejected_nodes.append( GSIRejectedDramaNodeScoringData(type(self), 'Club service is None.')) return False available_clubs = { club for club in club_service.get_clubs_for_sim_info( self._receiver_sim_info) } available_clubs &= { club for club in club_service.get_clubs_for_sim_info( self._sender_sim_info) } if not available_clubs: if gsi_data is not None: gsi_data.rejected_nodes.append( GSIRejectedDramaNodeScoringData(type(self), 'No available clubs.')) return False chosen_club = random.choice(tuple(available_clubs)) self._club_id = chosen_club.club_id return True
def _test(self, resolver, skip_run_tests=False): if self._club_id is None: return TestResult(False, 'Cannot run because there is no chosen node.') if self._sender_sim_info is None: return TestResult( False, 'Cannot run because there is no sender sim info.') if not skip_run_tests: club_service = services.get_club_service() if club_service is None: return TestResult(False, 'Club Service is None') club = club_service.get_club_by_id(self._club_id) if club is None: return TestResult( False, 'Cannot run because the club no longer exists.') if club in club_service.clubs_to_gatherings_map: return TestResult( False, 'Cannot run because the Club is already gathering') if self._sender_sim_info not in club.members: return TestResult( False, 'Cannot run because the sender sim info is no longer in the chosen club.' ) if self._receiver_sim_info not in club.members: return TestResult( False, 'Cannot run because the receiver sim info is no longer in the chosen club.' ) return super()._test(resolver, skip_run_tests=skip_run_tests)
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 should_transfer(self, continuation): club_service = services.get_club_service() if club_service is None: return False elif not club_service.interaction_is_encouraged_for_sim_info( self._interaction.sim.sim_info, continuation.aop): return False return True
def get_member_cap(self): cap = services.get_club_service().default_member_cap for ( perk, increase ) in club_tuning.ClubTunables.CLUB_MEMBER_CAPACITY_INCREASES.items(): if self.bucks_tracker.is_perk_unlocked(perk): cap += increase return cap
def request_club_invite(club_id: int, _connection=None): sim_info = services.active_sim_info() if sim_info is None: return club_service = services.get_club_service() if club_service is None: return club = club_service.get_club_by_id(club_id) if club is None: return if any(club_member.is_selectable for club_member in club.members): club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_ACTIVE_SIM) elif club in club_service.clubs_to_gatherings_map: club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_CURRENT_LOT) else: club_hangout_zone_id = club.get_hangout_zone_id() if club.hangout_setting == ClubHangoutSetting.HANGOUT_LOT: current_region = services.current_region() hangout_region = get_region_instance_from_zone_id( club_hangout_zone_id) if not current_region.is_region_compatible(hangout_region): club.show_club_notification( sim_info, ClubTunables. CLUB_GATHERING_DIALOG_REQUEST_INVITE_UNAVAILABLE, target_sim_id=club.leader.sim_id) return elif not club_hangout_zone_id: if services.active_lot_id() == services.active_household_lot_id(): def on_response(dialog): if dialog.accepted: club_service.start_gathering( club, host_sim_id=sim_info.sim_id, invited_sims=(sim_info, ), ignore_zone_validity=True) club.show_club_notification( sim_info, ClubTunables.CLUB_GATHERING_DIALOG_REQUEST_INVITE_NO_LOT, target_sim_id=club.leader.sim_id, on_response=on_response) else: club.show_club_notification( sim_info, ClubTunables. CLUB_GATHERING_DIALOG_REQUEST_INVITE_NO_LOT_NOT_HOME, target_sim_id=club.leader.sim_id) return club.show_club_gathering_dialog( sim_info, flavor_text=ClubTunables.CLUB_GATHERING_DIALOG_TEXT_REQUEST_INVITE, start_source=ClubGatheringStartSource.APPLY_FOR_INVITE)
def __repr__(self): club_service = services.get_club_service() if club_service is None: return 'No Club Service' return 'Except: {}, {}'.format( ','.join(str(club_seed) for club_seed in self.except_club_seeds), ','.join( str(club_service.get_club_by_id(club_id)) for club_id in self.except_club_ids))
def save(self, save_data): club_service = services.get_club_service() if club_service is not None: for club_seed in self.except_club_seeds: club = club_service.get_club_by_seed(club_seed) if club is not None: save_data.exception_sim_ids.append(club.club_id) save_data.exception_sim_ids.extend(self.except_club_ids) return super().save(save_data)
def get_sim_club_gathering(sim_identifier): sim_info = TurboManagerUtil.Sim.get_sim_info(sim_identifier) club_service = services.get_club_service() if club_service is not None: sim_clubs = club_service.get_clubs_for_sim_info(sim_info) for club in sim_clubs: club_gathering = club_service.clubs_to_gatherings_map.get(club) while club_gathering is not None: return (club, club_gathering) return (None, None)
def test_lock(self, sim): club_service = services.get_club_service() if club_service is not None and not any( club.club_id in self.except_club_ids or club.club_seed in self.except_club_seeds for club in club_service.get_clubs_for_sim_info(sim.sim_info)): return LockResult(True, 'club_lock', self.lock_priority, self.lock_sides) return LockResult(False, 'club_lock', self.lock_priority, self.lock_sides)
def _run(self): club_service = services.get_club_service() if club_service is None: return DramaNodeRunOutcome.FAILURE club = club_service.get_club_by_id(self._club_id) club.show_club_gathering_dialog( self._receiver_sim_info, flavor_text=ClubTunables.CLUB_GATHERING_DIALOG_TEXT_DRAMA_NODE, sender_sim_info=self._sender_sim_info) return DramaNodeRunOutcome.SUCCESS_NODE_COMPLETE
def open_reward(self, sim_info, **kwargs): club_service = services.get_club_service() if club_service is None: return sim = sim_info.get_sim_instance() if sim is None: return gathering = club_service.sims_to_gatherings_map.get(sim, None) if gathering is None: return gathering.set_club_vibe(self._vibe_to_set)
def reassign_leader(self, new_leader=None, prioritize_npcs=True, distribute=True): if new_leader not in self.members: new_leader = None if new_leader is None: new_leader = self._find_best_leader( prioritize_npcs=prioritize_npcs) if new_leader is None: self.disband() return if new_leader is self.leader: return self.leader = new_leader if distribute: services.get_club_service().distribute_club_update((self, )) services.get_event_manager().process_event(TestEvent.LeaderAssigned, sim_info=self.leader, associated_clubs=(self, ))
def can_sim_info_join(self, new_sim_info): if new_sim_info in self.members: return False if len(self.members) >= self.get_member_cap(): return False club_service = services.get_club_service() if not club_service.can_sim_info_join_more_clubs(new_sim_info): return False elif not self.validate_sim_info(new_sim_info): return False return True
def _apply_to_subject_and_target(self, subject, target, resolver): club_service = services.get_club_service() if club_service is None: return subject_sim = subject.get_sim_instance() if subject_sim is None: return gathering = club_service.sims_to_gatherings_map.get(subject_sim) if gathering is None: return gathering.set_club_vibe(self._vibe)
def get_clubs_gen(self, cls, inst, target, context, **kwargs): club_service = services.get_club_service() if club_service is None: return sim = context.sim if context is not None else inst.sim club_gathering = club_service.sims_to_gatherings_map.get(sim) if club_gathering is None: return for club in club_service.clubs_to_gatherings_map: if club is club_gathering.associated_club: continue yield club
def _get_club_requirement_filter_terms(config_data, filter_terms=[]): club_service = services.get_club_service() if club_service is None: return club_id = UniversityUtils._get_club_id_from_configuration(config_data) if club_id is None or club_service.get_club_by_id(club_id) is None: return criteria = UniversityHousingRoommateRequirementCriteria.CLUB club_filter_term = UniversityHousingTuning.UNIVERSITY_HOUSING_ROOMMATE_FILTER_TERM_TEMPLATES[ criteria] club_filter_term.set_specific_club_id(club_id) filter_terms.append(club_filter_term)
def remove_member(self, member, distribute=True, can_reassign_leader=True, from_stop=False): if member not in self.members: logger.error( "Attempting to remove {} from club {} but they aren't a member.", member, self) return club_service = services.get_club_service() club_rule_mapping = club_service.club_rule_mapping for rule in self.rules: for affordance in rule.action(): club_rule_mapping[member][affordance].remove(rule) if not club_rule_mapping[member][affordance]: del club_rule_mapping[member][affordance] if not club_rule_mapping[member]: del club_rule_mapping[member] club_service._sim_infos_to_clubs_map[member].remove(self) if not club_service._sim_infos_to_clubs_map[member]: del club_service._sim_infos_to_clubs_map[member] if not from_stop: for buff in club_tuning.ClubTunables.BUFFS_NOT_IN_ANY_CLUB: member.add_buff(buff.buff_type) member_instance = member.get_sim_instance() current_gathering = club_service.sims_to_gatherings_map.get( member_instance) if current_gathering is not None and current_gathering.associated_club is self: current_gathering.remove_sim_from_situation(member_instance) self.members.remove(member) self._recent_member_ids.discard(member.sim_id) if member is self.leader: self.leader = None if can_reassign_leader: self.reassign_leader(prioritize_npcs=not member.is_selectable, distribute=distribute) club_service.reset_sim_info_interaction_club_rewards_cache( sim_info=member) if distribute: club_service.distribute_club_update((self, )) zone = services.current_zone() if zone.is_zone_running: self.validate_club_hangout() with telemetry_helper.begin_hook(club_telemetry_writer, TELEMETRY_HOOK_CLUB_QUIT, sim_info=member) as hook: hook.write_int(TELEMETRY_FIELD_CLUB_ID, self.id) services.get_event_manager().process_event( TestEvent.ClubMemberRemoved, sim_info=member, associated_clubs=(self, ))
def get_club_from_service_by_id(club_id, _connection): club_service = services.get_club_service() if club_service is None: sims4.commands.output('A Pack with Clubs/Groups is not installed.', _connection) return else: club = club_service.get_club_by_id(club_id) if club is None: sims4.commands.output( 'Club not found with id {}. Please Specify an existing club id.' .format(club_id), _connection) return return club
def _run(self): def on_response(dialog): if dialog.accepted: club = services.get_club_service().get_club_by_id( self._club_id) self._run_club_behavior(club) services.drama_scheduler_service().complete_node(self.uid) dialog = self.dialog(self._receiver_sim_info, target_sim_id=self._sender_sim_info.id, resolver=self._get_resolver()) club = services.get_club_service().get_club_by_id(self._club_id) dialog.show_dialog(on_response=on_response, additional_tokens=(club.name, )) return DramaNodeRunOutcome.SUCCESS_NODE_INCOMPLETE
def on_response(dialog): if not dialog.accepted: return persistence_service = services.get_persistence_service() if persistence_service.is_save_locked(): return club_service = services.get_club_service() if club_service is None: return club_service.start_gathering(self, start_source=start_source, host_sim_id=sim_info.sim_id, invited_sims=(sim_info, ), zone_id=zone_id, spawn_sims_during_zone_spin_up=True)