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