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)
