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 _apply_to_subject_and_target(self, subject, target, resolver):
knowledge = subject.relationship_tracker.get_knowledge(target.sim_id,
initialize=True)
if knowledge is None or knowledge.knows_career:
return
knowledge.add_knows_career(target.sim_id)
career_tracker = target.career_tracker
if career_tracker.has_custom_career:
career_tracker.custom_career_data.show_custom_career_knowledge_notification(
subject, DoubleSimResolver(subject, target))
return
for career in knowledge.get_known_careers():
career.show_knowledge_notification(
subject, DoubleSimResolver(subject, target))
def _show_npc_dialog(self):
for tuning_data in self.MULTIPLE_OFFSPRING_CHANCES:
if tuning_data.size == self.offspring_count:
npc_dialog = tuning_data.npc_dialog
if npc_dialog is not None:
for parent in self.get_parents():
if parent is None:
logger.error(
'Pregnancy for {} has a None parent for IDs {}. Please file a DT with a save attached.',
self._sim_info, ','.join(
str(parent_id)
for parent_id in self._parent_ids))
return
parent_instance = parent.get_sim_instance()
if parent_instance is not None:
if parent_instance.client is not None:
additional_tokens = list(
itertools.chain(self.get_parents(),
self._offspring_data))
dialog = npc_dialog(
parent_instance,
DoubleSimResolver(additional_tokens[0],
additional_tokens[1]))
dialog.show_dialog(
additional_tokens=additional_tokens)
return
def _try_to_be_invited_in(self):
if self._always_allow_greeting:
self._make_greeted()
return
owner_sim_infos = self._get_owner_sim_infos()
if owner_sim_infos is None:
self._show_nobody_home_dialog()
return
occupants = tuple(sim_info for sim_info in owner_sim_infos
if sim_info.is_at_home)
num_occupants = len(occupants)
for sim_info in occupants:
if sim_info.is_pet:
num_occupants -= 1
else:
sim = sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS)
if not sim is None:
if sim.has_running_and_queued_interactions_with_liability(
interactions.rabbit_hole.RABBIT_HOLE_LIABILTIY):
num_occupants -= 1
num_occupants -= 1
if num_occupants == 0:
self._show_nobody_home_dialog()
return
for occupant in occupants:
relationship_resolver = DoubleSimResolver(self.sim.sim_info,
occupant)
if relationship_resolver(self._relationship_test):
self._make_greeted()
return
dialog = self._bad_relationship_failure_notification(
self.sim, resolver)
dialog.show_dialog()
def _apply_to_subject_and_target(self, subject, target, resolver):
if subject is None:
logger.error(
'Attempting to play a reaction on a None subject for participant {}. Loot: {}',
self.subject,
self,
owner='rmccord')
return
if not subject.is_sim:
logger.error(
'Attempting to play a reaction on subject: {}, that is not a Sim. Loot: {}',
self.subject,
self,
owner='rmccord')
return
target_sim_info = resolver.get_participant(self.greeting_target)
greeting_resolver = DoubleSimResolver(subject, target_sim_info)
subject_sim = subject.get_sim_instance()
if subject_sim is None:
return
target_sim = target_sim_info.get_sim_instance()
if target_sim is None:
return
if self.greeting_type == GreetingType.GREETING_TARGETED:
try_push_targeted_greeting_for_sim(subject_sim, target_sim,
greeting_resolver)
elif self.greeting_type == GreetingType.GREETING_GROUP:
try_push_group_greeting_for_sim(subject_sim, target_sim,
greeting_resolver)
def _relationship_added_callback(self, relationship):
resolver = DoubleSimResolver(relationship.find_sim_info_a(), relationship.find_sim_info_b(), additional_participants={ParticipantType.AssociatedClub: (self.associated_club,)})
for (perk, benefit) in ClubTunables.NEW_RELATIONSHIP_MODS.items():
if self.associated_club.bucks_tracker.is_perk_unlocked(perk):
if not benefit.test_set.run_tests(resolver=resolver):
continue
benefit.loot.apply_to_resolver(resolver=resolver)
def apply_loot(self, sim):
target_info = services.sim_info_manager().get(sim.id)
target_resolver = SingleSimResolver(target_info)
self.target_loot.apply_to_resolver(target_resolver)
photographer_info = services.sim_info_manager().get(
self.photographer.id)
photographer_resolver = SingleSimResolver(photographer_info)
self.photographer_loot.apply_to_resolver(photographer_resolver)
tracker = target_info.get_tracker(self.statistic_info.statistic)
current_statvalue = tracker.get_value(self.statistic_info.statistic)
change_amount = abs(current_statvalue - self.stored_statistic_value)
if self.photographer is None:
logger.error(
'Got a None Sim {} while applying loot to the photographer.',
self.photographer,
owner='shipark')
if self.notification is None:
return
notification = self.notification(self.photographer,
resolver=DoubleSimResolver(
photographer_info, target_info),
target_sim_id=sim.id)
if change_amount > 0:
notification.show_dialog(additional_tokens=(change_amount, ))
else:
notification.show_dialog()
def get_resolver_for_gig(self):
if self._customer_id is not None:
customer_sim_info = services.sim_info_manager().get(
self._customer_id)
if customer_sim_info is not None:
return DoubleSimResolver(self._owner, customer_sim_info)
return SingleSimResolver(self._owner)
def validate_partner(self):
impregnator = self.get_partner()
if impregnator is None:
return
resolver = DoubleSimResolver(self._sim_info, impregnator)
if not self.AT_BIRTH_TESTS.run_tests(resolver):
self._parent_ids = (self._sim_info.id, self._sim_info.id)
def schedule_node(drama_node: TunableInstanceParam(
sims4.resources.Types.DRAMA_NODE),
actor_sim_id: OptionalSimInfoParam = None,
target_sim_id: OptionalSimInfoParam = None,
days_from_now: int = None,
_connection=None):
actor_sim_info = get_optional_target(actor_sim_id, _connection,
OptionalSimInfoParam)
if target_sim_id is not None:
target_sim_info = get_optional_target(target_sim_id, _connection,
OptionalSimInfoParam)
else:
target_sim_info = None
specific_time = None
if days_from_now is not None:
scheduled_day = int(
services.time_service().sim_now.absolute_days()) + days_from_now
specific_time = create_date_and_time(days=scheduled_day)
resolver = DoubleSimResolver(actor_sim_info, target_sim_info)
uid = services.drama_scheduler_service().schedule_node(
drama_node, resolver, specific_time=specific_time)
if uid is not None:
sims4.commands.output(
'Successfully scheduled drama node: {}'.format(
drama_node.__name__), _connection)
else:
sims4.commands.output(
'Failed to scheduled drama node: {}'.format(drama_node.__name__),
_connection)
def situation_meets_starting_requirements(cls, **kwargs):
neighbor_results = cls.get_filter_results_for_job()
for neighbor_result in neighbor_results:
resolver = DoubleSimResolver(services.active_sim_info(),
neighbor_result.sim_info)
if cls.scheduling_tests.run_tests(resolver):
return True
return False
def _choose_dialog(self):
choices = []
resolver = DoubleSimResolver(self._receiver_sim_info, self._sender_sim_info)
for dialog_data in self._NPC_hosted_situation_start_messages:
if dialog_data.tests.run_tests(resolver):
choices.append(dialog_data.dialog)
if choices:
self._chosen_dialog = random.choice(choices)
def _can_sim_pass_test(cls, target_sim_info, actor_sim_info,
inherited_target_sim_info):
if not super(SituationGoalRelationshipChangeTargetedSim,
cls)._can_sim_pass_test(target_sim_info, actor_sim_info,
inherited_target_sim_info):
return False
resolver = DoubleSimResolver(actor_sim_info, target_sim_info)
return resolver(cls._relationship_pretest)
def factory(sim_info, relationship_test):
relationship_match = None
for relation in sim_info.relationship_tracker:
relation_sim_info = services.sim_info_manager().get(
relation.get_other_sim_id(sim_info.sim_id))
if relation_sim_info is not None:
if not relation_sim_info.is_baby:
if relation_sim_info.is_instanced():
resolver = DoubleSimResolver(sim_info,
relation_sim_info)
relationship_match = resolver(relationship_test)
if relationship_match:
return relation_sim_info
resolver = DoubleSimResolver(sim_info, relation_sim_info)
relationship_match = resolver(relationship_test)
if relationship_match:
return relation_sim_info
def _apply_to_subject_and_target(self, subject, target, resolver):
knowledge = subject.relationship_tracker.get_knowledge(target.sim_id,
initialize=True)
if knowledge is None or knowledge.knows_major:
return
knowledge.add_knows_major(target.sim_id)
degree_tracker = target.degree_tracker
degree_tracker.show_knowledge_notification(
subject, DoubleSimResolver(subject, target))
def _run_relationship_tests(self, pet_info):
num_sims = 0
num_rel_tests_passed = 0
for sim in self._household.instanced_sims_gen():
if sim.sim_info.species == Species.HUMAN:
num_sims += 1
resolver = DoubleSimResolver(pet_info, sim.sim_info)
if self.RELATIONSHIP_TESTS.run_tests(resolver):
num_rel_tests_passed += 1
return num_rel_tests_passed > num_sims/2
def _on_interaction_of_interest_complete(self, **kwargs):
chef_feedback_infos = self.owner._chef_feedback.pop(self._chef_sim, None)
for chef_feedback_info in chef_feedback_infos:
double_sim_resolver = DoubleSimResolver(chef_feedback_info.from_sim, self._chef_sim)
if chef_feedback_info.is_compliment:
ChefTuning.CHEF_COMPLIMENT_LOOT.apply_to_resolver(double_sim_resolver)
else:
ChefTuning.CHEF_INSULT_LOOT.apply_to_resolver(double_sim_resolver)
next_state = self._get_next_state()
self._change_state(next_state())
def _can_sim_pass_test(cls, target_sim_info, actor_sim_info,
inherited_target_sim_info):
if cls._target_option == SituationGoalSimTargetingOptions.GoalSystemChoiceExcludingInherited and target_sim_info is inherited_target_sim_info:
return False
if actor_sim_info is None:
return True
if actor_sim_info.id == target_sim_info.id:
return False
double_sim_resolver = DoubleSimResolver(actor_sim_info,
target_sim_info)
return cls._target_tests.run_tests(double_sim_resolver)
def _apply_aging_transition_relbit_loot(self, source_info, cur_info, relbit_based_loot, level):
if level == len(relbit_based_loot.relationship):
resolver = DoubleSimResolver(source_info, cur_info)
for loot in relbit_based_loot.loot:
loot.apply_to_resolver(resolver)
return
relationship_tracker = cur_info.relationship_tracker
for target_sim_id in relationship_tracker.target_sim_gen():
if set(relationship_tracker.get_all_bits(target_sim_id)) & relbit_based_loot.relationship[level]:
new_sim_info = services.sim_info_manager().get(target_sim_id)
self._apply_aging_transition_relbit_loot(source_info, new_sim_info, relbit_based_loot, level + 1)
def _end_situation(self):
active_sim_info = services.active_sim_info()
agent = next(iter(self.owner.all_sims_in_situation_gen()))
notification = self._timeout_notification(active_sim_info,
resolver=DoubleSimResolver(
active_sim_info, agent))
notification.show_dialog()
situation_manger = services.get_zone_situation_manager()
for sim in self.owner.all_sims_in_situation_gen():
situation_manger.make_sim_leave_now_must_run(sim)
self.owner._self_destruct()
def _run(self):
if self.confirm_dialog:
sim_info = self._receiver_sim_info
resolver = DoubleSimResolver(self._sender_sim_info,
self._receiver_sim_info)
confirm_dialog = self.confirm_dialog(sim_info, resolver=resolver)
confirm_dialog.show_dialog(
on_response=self._on_confirm_dialog_response)
return DramaNodeRunOutcome.SUCCESS_NODE_INCOMPLETE
else:
self._run_situation()
return DramaNodeRunOutcome.SUCCESS_NODE_COMPLETE
def _sim_filter_loot_response(self, filter_results, callback_event_data):
entry = callback_event_data
if entry.max_sims is None:
targets = tuple(result.sim_info for result in filter_results)
else:
sample_size = min(len(filter_results), entry.max_sims)
targets = tuple(
result.sim_info
for result in random.sample(filter_results, sample_size))
for target in targets:
resolver = DoubleSimResolver(self.sim_info, target)
entry.loot.apply_to_resolver(resolver)
def _update_visiblity(self):
if not self.visible_to_client:
sim_info_manager = services.sim_info_manager()
sim_info_a = sim_info_manager.get(self.tracker.rel_data.sim_id_a)
if sim_info_a is None:
return
sim_info_b = sim_info_manager.get(self.tracker.rel_data.sim_id_b)
if sim_info_b is None:
return
resolver = DoubleSimResolver(sim_info_a, sim_info_b)
self.visible_to_client = True if self.visible_test_set.run_tests(
resolver) else False
def remove_social_group_decay(self):
if self.socialization_decay_modifier != 1:
self.remove_decay_rate_modifier(self.socialization_decay_modifier)
if self.decay_to_initial_modifier:
if self.tested_initial_modifier is not None:
sim_info_a = self.tracker.rel_data.relationship.find_sim_info_a(
)
sim_info_b = self.tracker.rel_data.relationship.find_sim_info_b(
)
if sim_info_a is None or sim_info_b is None:
return
self.convergence_value = self._default_convergence_value + self.tested_initial_modifier.get_max_modifier(
DoubleSimResolver(sim_info_a, sim_info_b))
def _on_player_interaction_complete(self, actor_sim_info):
if self._showing_dialog:
return
self._showing_dialog = True
target_sim = self.owner.get_pet_owner()
pet_sim = self.owner.get_pet()
if target_sim is None or pet_sim is None:
self.owner._self_destruct()
self.owner.log_flow_entry('Presenting Service Request Dialog')
dialog = self.service_request_dialog(actor_sim_info,
resolver=DoubleSimResolver(
pet_sim, target_sim))
dialog.show_dialog(on_response=self._on_dialog_response)
def apply_aging_transition_loot(self, sim_info):
if self.per_household_member_loot:
for member_info in sim_info.household.sim_info_gen():
if member_info is sim_info:
continue
resolver = DoubleSimResolver(sim_info, member_info)
for household_loot in self.per_household_member_loot:
household_loot.apply_to_resolver(resolver)
for relbit_based_loot in self.relbit_based_loot:
self._apply_aging_transition_relbit_loot(sim_info, sim_info, relbit_based_loot, 0)
resolver = SingleSimResolver(sim_info)
for loot in self.single_sim_loot:
loot.apply_to_resolver(resolver)
def _update_visiblity(self):
if not self.visible_to_client:
sim_info_manager = services.sim_info_manager()
actor_sim_info = sim_info_manager.get(
self.tracker.relationship.sim_id)
if actor_sim_info is None:
return
target_sim_info = sim_info_manager.get(
self.tracker.relationship.target_sim_id)
if target_sim_info is None:
return
resolver = DoubleSimResolver(actor_sim_info, target_sim_info)
self.visible_to_client = True if self.visible_test_set.run_tests(
resolver) else False
def show_club_notification(self,
sim_info,
notification_type,
target_sim_id=None,
additional_tokens=(),
on_response=None):
notification = notification_type(sim_info,
resolver=DoubleSimResolver(
sim_info, self.leader),
target_sim_id=target_sim_id)
notification.show_dialog(
additional_tokens=(self.name, ) + tuple(additional_tokens),
icon_override=IconInfoData(icon_resource=self.icon),
on_response=on_response)
def apply(self,
relationship,
actor_sim_id,
target_sim_id,
bits_only=False):
sim_to_target_tracker = relationship.relationship_track_tracker
if not bits_only:
try:
sim_to_target_tracker.suppress_callback_setup_during_load = True
sim_to_target_tracker.load_in_progress = True
for data in self.relationship_tracks:
track = data.track
value = data.value
relationship_track = sim_to_target_tracker.get_statistic(
track, True)
if relationship_track is None:
continue
if relationship_track.get_value() < value:
sim_to_target_tracker.set_value(
track, value, apply_initial_modifier=True)
(old_bit,
new_bit) = relationship_track.update_instance_data()
if old_bit is not None and old_bit is not new_bit:
relationship.remove_bit(actor_sim_id, target_sim_id,
old_bit)
if new_bit is not None and not relationship.has_bit(
actor_sim_id, new_bit):
relationship.add_relationship_bit(
actor_sim_id, target_sim_id, new_bit)
relationship_track.fixup_callbacks_during_load()
finally:
sim_to_target_tracker.suppress_callback_setup_during_load = False
sim_to_target_tracker.load_in_progress = False
for bit in self.relationship_bits:
relationship.add_relationship_bit(actor_sim_id, target_sim_id, bit)
sim_info_manager = services.sim_info_manager()
actor_sim_info = sim_info_manager.get(actor_sim_id)
target_sim_info = sim_info_manager.get(target_sim_id)
resolver = DoubleSimResolver(actor_sim_info, target_sim_info)
for random_relationships in self.random_relationship_bits:
weights = []
for random_bit in random_relationships:
weight = random_bit.weight.get_multiplier(resolver)
if weight > 0:
weights.append((weight, random_bit.bit))
if weights:
selected_bit = sims4.random.weighted_random_item(weights)
relationship.add_relationship_bit(actor_sim_id, target_sim_id,
selected_bit)
def factory(sim_info, relationship_test):
relationship_match = None
for relation in sim_info.relationship_tracker:
relation_sim_info = services.sim_info_manager().get(
relation.relationship_id)
while relation_sim_info is not None and (
relation_sim_info.is_baby
or relation_sim_info.is_instanced()):
resolver = DoubleSimResolver(sim_info, relation_sim_info)
relationship_match = resolver(relationship_test)
if relationship_match:
return relation_sim_info
if relationship_match is None:
return TestResult(False, 'No target Relation Found')
return relationship_match
