def select_career(sim_id:int=None, career_instance_id:int=None, track_id:int=None, level:int=None, company_name_hash:int=None, reason:int=CareerOps.JOIN_CAREER, _connection=None):
if sim_id is None or (career_instance_id is None or track_id is None) or level is None:
logger.error('Not all of the data needed for the careers.select command was passed.')
return False
career_manager = services.get_instance_manager(sims4.resources.Types.CAREER)
career_type = career_manager.get(career_instance_id)
if career_type is None:
logger.error('invalid career Id sent to careers.select')
return False
sim = services.object_manager().get(sim_id)
if sim_id is None:
logger.error('invalid sim Id passed to careers.select')
return False
career_track_manager = services.get_instance_manager(sims4.resources.Types.CAREER_TRACK)
career_track = career_track_manager.get(track_id)
if career_track is None:
logger.error('invalid career track Id passed to careers.select')
return False
if reason is None:
logger.error('invalid career selection reason passed to careers.select')
return False
career_tracker = sim.sim_info.career_tracker
if reason == CareerOps.JOIN_CAREER:
current_career = career_tracker.get_career_by_uid(career_instance_id)
if current_career is not None:
current_career.set_new_career_track(track_id)
else:
career_tracker.add_career(career_type(sim.sim_info, company_name=company_name_hash), show_confirmation_dialog=True)
if reason == CareerOps.QUIT_CAREER:
career_tracker.remove_career(career_instance_id)
def offer_goals(self, debug_goal=None, debug_target=None, request_single_goal=False, emotion_only=False):
if not self.emotion_whim_needed and self.whims_needed == 0:
return
if self._sim_info.is_npc:
return
if self._sim is None:
return
chosen_tuned_goals = {}
if self.whims_needed > 0:
normal_whimset_list = services.get_instance_manager(sims4.resources.Types.ASPIRATION).normal_whim_sets
prioritized_tuned_whim_sets = []
for whim_set in normal_whimset_list:
priority = self.get_priority(whim_set)
while priority != 0:
prioritized_tuned_whim_sets.append((priority, whim_set))
if not emotion_only:
self._select_goals(prioritized_tuned_whim_sets, chosen_tuned_goals, debug_goal, debug_target, request_single_goal)
if self.emotion_whim_needed:
emotion_whimset_list = services.get_instance_manager(sims4.resources.Types.ASPIRATION).emotion_whim_sets
prioritized_tuned_whim_sets = []
for whim_set in emotion_whimset_list:
priority = self.get_priority(whim_set)
while priority != 0 and whim_set.whimset_emotion is self._sim_mood:
prioritized_tuned_whim_sets.append((priority, whim_set))
self._select_goals(prioritized_tuned_whim_sets, chosen_tuned_goals, debug_goal, debug_target)
if self._goals_dirty:
index = 0
for tuned_goal in chosen_tuned_goals:
goal_added = False
if chosen_tuned_goals[tuned_goal].whimset_emotion is not None:
goal = tuned_goal(sim_info=self._sim_info, goal_id=self._goal_id_generator(), inherited_target_sim_info=self._whimset_target_map[chosen_tuned_goals[tuned_goal]])
self._active_whims[WhimsTracker.MAX_GOALS] = goal
goal_added = True
else:
while index < WhimsTracker.MAX_GOALS:
if self._active_whims[index] is None:
goal = tuned_goal(sim_info=self._sim_info, goal_id=self._goal_id_generator(), inherited_target_sim_info=self._whimset_target_map[chosen_tuned_goals[tuned_goal]])
self._active_whims[index] = goal
goal_added = True
break
index += 1
if goal_added:
self._realized_goals[goal] = chosen_tuned_goals[tuned_goal]
goal.register_for_on_goal_completed_callback(self._on_goal_completed)
logger.debug('Added whim for {}: {}', self._sim_info, goal, owner='jjacobson')
else:
logger.error('Trying to add a whim when the active whims are already full.', owner='jjacobson.')
with telemetry_helper.begin_hook(writer, TELEMETRY_HOOK_WHIM_EVENT, sim=self._sim_info) as hook:
hook.write_int(TELEMETRY_WHIM_EVENT_TYPE, TelemetryWhimEvents.ADDED)
hook.write_guid(TELEMETRY_WHIM_GUID, goal.guid64)
if len(self._realized_goals) > WhimsTracker.MAX_GOALS + 1:
logger.error('Too many whims active. Current Whims: {}', self._realized_goals.keys(), owner='jjacobson')
def _verify_tuning_callback(cls):
if cls.use_ingredients:
for ingredient in cls.use_ingredients.ingredient_list:
while ingredient is None:
logger.error('Recipe {} has unset ingredients', cls.__name__)
if not cls.use_ingredients.ingredient_list:
logger.error('Recipe {} has an empty ingredient list and its tuned to use ingredients.', cls.__name__)
if not cls.name:
logger.error('Recipe {} does not have a name set', cls.__name__)
if not cls.phase_interaction_name:
logger.error('Recipe {} does not have a phase interaction name set', cls.__name__)
cls._validate_final_product()
services.get_instance_manager(sims4.resources.Types.RECIPE).add_on_load_complete(cls.validate_base_recipe)
def start(self):
self._enabled = True
for aspiration in services.get_instance_manager(sims4.resources.Types.ASPIRATION).types.values():
while not aspiration.disabled:
self.register_single_event(aspiration, TestEvent.UpdateObjectiveData)
self._handlers_to_unregister_post_load.add(aspiration)
if not aspiration.complete_only_in_sequence:
aspiration.register_callbacks()
for achievement in services.get_instance_manager(sims4.resources.Types.ACHIEVEMENT).types.values():
while not achievement.disabled:
self.register_single_event(achievement, TestEvent.UpdateObjectiveData)
self._handlers_to_unregister_post_load.add(achievement)
achievement.register_callbacks()
def has_zone_for_venue_type(self, venue_types):
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
venue_type = venue_manager.get(venue_type_id)
if venue_type and venue_type in venue_types:
return True
instance_manager = services.get_instance_manager(sims4.resources.Types.MAXIS_LOT)
for lot_instance in instance_manager.types.values():
while lot_instance.supports_any_venue_type(venue_types):
return True
return False
def load(self, save_data):
trait_manager = services.get_instance_manager(sims4.resources.Types.TRAIT)
self._num_traits = save_data.num_traits
for trait_inst_id in save_data.trait_ids:
trait = trait_manager.get(trait_inst_id)
while trait is not None:
self.known_traits.add(trait)
def load(self, crafting_process_message):
recipe_manager = services.get_instance_manager(sims4.resources.Types.RECIPE)
self.recipe = recipe_manager.get(crafting_process_message.recipe_id)
for phase in self.recipe.phases.values():
if phase.id == crafting_process_message.phase_id:
self.phase = phase
else:
while phase.id == crafting_process_message.previous_phase_id:
self._previous_phase = phase
current_ico = services.object_manager().get(crafting_process_message.current_ico)
if current_ico is None:
current_ico = services.inventory_manager().get(crafting_process_message.current_ico)
if current_ico is not None:
self._current_ico_ref = current_ico.ref()
if crafting_process_message.crafter_sim_id != 0:
self._crafter_sim_id = crafting_process_message.crafter_sim_id
self.add_order(self._crafter_sim_id, self.recipe)
if crafting_process_message.HasField('inscription'):
self.inscription = crafting_process_message.inscription
if crafting_process_message.HasField('crafted_value'):
self.crafted_value = crafting_process_message.crafted_value
statistic_component = self.get_component(objects.components.types.STATISTIC_COMPONENT)
statistic_tracker = statistic_component.get_statistic_tracker()
if statistic_tracker is not None:
statistic_tracker.load(crafting_process_message.statistic_tracker.statistics)
def generate_aspiration_view_data(sim_id:int=None):
sim_info = services.sim_info_manager().get(sim_id)
aspiration_manager = services.get_instance_manager(sims4.resources.Types.ASPIRATION)
all_aspirations = []
for aspiration_id in aspiration_manager.types:
aspiration = aspiration_manager.get(aspiration_id)
aspiration_data = {}
aspiration_data['aspiration'] = str(aspiration)
aspiration_data['aspiration_uid'] = int(aspiration.guid64)
if issubclass(aspiration, Aspiration):
aspiration_data['display_name'] = str(hex(aspiration.display_name.hash))
aspiration_data['description'] = str(hex(aspiration.descriptive_text.hash))
aspiration_data['auto_select'] = str(aspiration)
aspiration_data['aspiration_complete'] = False
aspiration_data['objectives'] = []
aspiration_data['simId'] = str(sim_id)
if not sim_info.aspiration_tracker.milestone_completed(aspiration.guid64):
for objective in aspiration.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
if sim_info.aspiration_tracker.objective_completed(objective.guid64):
objective_data['objective_complete'] = True
else:
objective_data['objective_complete'] = False
aspiration_data['objectives'].append(objective_data)
else:
aspiration_data['aspiration_complete'] = True
for objective in aspiration.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
objective_data['objective_complete'] = True
aspiration_data['objectives'].append(objective_data)
all_aspirations.append(aspiration_data)
return all_aspirations
def get_tunable_instance(resource_type, name_string_or_id, exact_match=False):
manager = services.get_instance_manager(resource_type)
cls = manager.get(name_string_or_id)
if cls is not None:
return cls
if not sims4.commands.check_permission(sims4.commands.CommandType.DebugOnly):
raise ValueError()
search_string = str(name_string_or_id).lower()
match = None
for cls in manager.types.values():
if exact_match:
if search_string == cls.__name__.lower():
return cls
if search_string == cls.__name__.lower():
return cls
while search_string in cls.__name__.lower():
if match is not None:
raise ValueError("Multiple names matched '{}': {}, {}, ...".format(search_string, match, cls))
match = cls
else:
if search_string == cls.__name__.lower():
return cls
while search_string in cls.__name__.lower():
if match is not None:
raise ValueError("Multiple names matched '{}': {}, {}, ...".format(search_string, match, cls))
match = cls
if match is None:
raise ValueError("No names matched '{}'.".format(search_string))
return match
def get_career_entry_level(self, career_history=None, resolver=None):
if career_history is None or self.guid64 not in career_history:
level = int(self.start_level_modifiers.get_max_modifier(resolver))
max_level = len(self.start_track.career_levels)
level = sims4.math.clamp(0, level, max_level - 1)
return (level, level + 1, None)
history = career_history[self.guid64]
new_level = history.career_level
new_user_level = history.user_level
time_left = history.time_left
current_track_uid = history.track_uid
current_track = services.get_instance_manager(sims4.resources.Types.CAREER_TRACK).get(current_track_uid)
new_level -= self.levels_lost_on_leave
new_user_level -= self.levels_lost_on_leave
current_time = services.time_service().sim_now
time_gone_from_career = current_time - time_left
days_gone_from_career = time_gone_from_career.in_days()
if self.days_to_level_loss > 0:
levels_to_lose = int(days_gone_from_career/self.days_to_level_loss)
new_level -= levels_to_lose
new_user_level -= levels_to_lose
if new_level < 0:
new_level = 0
if new_user_level < 1:
new_user_level = 1
return (new_level, new_user_level, current_track)
def generate_achievement_view_data(sim_id:int=None):
sim_info = services.sim_info_manager().get(sim_id)
achievement_manager = services.get_instance_manager(sims4.resources.Types.ACHIEVEMENT)
all_achievements = []
for achievement_id in achievement_manager.types:
achievement = achievement_manager.get(achievement_id)
achievement_data = {}
achievement_data['achievement'] = str(achievement)
achievement_data['achievement_uid'] = int(achievement.guid64)
achievement_data['category'] = str(achievement.category)
achievement_data['points'] = int(achievement.point_value)
achievement_data['display_name'] = str(hex(achievement.display_name.hash))
achievement_data['description'] = str(hex(achievement.descriptive_text.hash))
achievement_data['achievement_complete'] = False
achievement_data['objectives'] = []
achievement_data['simId'] = str(sim_id)
if not sim_info.account.achievement_tracker.milestone_completed(achievement.guid64):
for objective in achievement.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
if sim_info.account.achievement_tracker.objective_completed(objective.guid64):
objective_data['objective_complete'] = True
else:
objective_data['objective_complete'] = False
achievement_data['objectives'].append(objective_data)
else:
achievement_data['achievement_complete'] = True
for objective in achievement.objectives:
objective_data = {}
objective_data['objective'] = str(objective)
objective_data['objective_complete'] = True
achievement_data['objectives'].append(objective_data)
all_achievements.append(achievement_data)
return all_achievements
def get_valid_situation_locations(sim_id, situation_type, *guests, _connection=None):
sim = get_optional_target(sim_id, _connection)
if not sim:
sims4.commands.output('Invalid Sim ID: {}'.format(sim_id), _connection)
return
sim_info = sim.sim_info
possible_zones = []
possible_zones.append(sim_info.household.home_zone_id)
for guest_id in guests:
guest_id = int(guest_id)
guest_info = services.sim_info_manager().get(guest_id)
while guest_info is not None:
guest_zone_id = guest_info.household.home_zone_id
if guest_zone_id is not None and guest_zone_id and guest_zone_id not in possible_zones:
possible_zones.append(guest_zone_id)
venue_service = services.current_zone().venue_service
for venue_type in situation_type.venue_types:
possible_zones.extend(venue_service.get_zones_for_venue_type(venue_type))
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
persistence_service = services.get_persistence_service()
locations_msg = Situations_pb2.SituationLocations()
cas_zones_msg = InteractionOps_pb2.CASAvailableZonesInfo()
world_info_msg = cas_zones_msg.zones.add()
for zone_id in possible_zones:
zone_data = persistence_service.get_zone_proto_buff(zone_id)
if zone_data is None:
pass
neighborhood_data = persistence_service.get_neighborhood_proto_buff(zone_data.neighborhood_id)
if neighborhood_data is None:
pass
lot_data = None
for lot_owner_data in neighborhood_data.lots:
while zone_id == lot_owner_data.zone_instance_id:
lot_data = lot_owner_data
break
while zone_data is not None and lot_data is not None:
location_data = Dialog_pb2.LotInfoItem()
location_data.zone_id = zone_data.zone_id
location_data.name = zone_data.name
location_data.world_id = zone_data.world_id
location_data.lot_template_id = zone_data.lot_template_id
location_data.lot_description_id = zone_data.lot_description_id
venue_type_id = build_buy.get_current_venue(zone_id)
venue_instance = venue_manager.get(venue_type_id)
if venue_instance is not None:
location_data.venue_type_name = venue_instance.display_name
if lot_data.lot_owner:
household_id = lot_data.lot_owner[0].household_id
household = services.household_manager().get(household_id)
if household is not None:
location_data.household_name = household.name
locations_msg.situation_locations.append(location_data)
with ProtocolBufferRollback(world_info_msg.zones) as zone_info_msg:
zone_info_msg.id = zone_data.zone_id
zone_info_msg.name = zone_data.name
zone_info_msg.world_id = zone_data.world_id
zone_info_msg.lot_template_id = zone_data.lot_template_id
zone_info_msg.lot_description_id = zone_data.lot_description_id
shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_NS_AVAILABLE_ZONES_INFO, cas_zones_msg)
shared_messages.add_object_message_for_sim_id(sim.id, Consts_pb2.MSG_SITUATION_LOCATIONS, locations_msg)
def tuning_reload(_connection=None):
sims4.callback_utils.invoke_callbacks(sims4.callback_utils.CallbackEvent.TUNING_CODE_RELOAD)
done = set()
dependents = set()
for manager in get_managers().values():
for changed in manager.get_changed_files():
done.add(changed)
new_dependents = manager.reload_by_key(changed)
while new_dependents is not None:
dependents.update(new_dependents)
dependents.difference_update(done)
while dependents:
next_dependent = dependents.pop()
done.add(next_dependent)
next_type = next_dependent.type
manager = services.get_instance_manager(next_type)
new_dependents = manager.reload_by_key(next_dependent)
while new_dependents is not None:
new_dependents.difference_update(done)
dependents.update(new_dependents)
continue
sims4.commands.output('Reloading definitions tags: Begin.', _connection)
services.definition_manager().refresh_build_buy_tag_cache()
sims4.commands.output('Reloading definitions tags: End.', _connection)
sims4.commands.output('Reload done', _connection)
return True
def find_household_template_that_contains_sim_filter(cls, sim_creations_to_match):
valid_filter_template_type = []
if cls._household_templates_override:
templates_to_iterate_over = cls._household_templates_override
else:
templates_to_iterate_over = services.get_instance_manager(sims4.resources.Types.SIM_TEMPLATE).types.values()
for filter_template_type in templates_to_iterate_over:
if filter_template_type.template_type == filters.sim_template.SimTemplateType.SIM:
pass
index_to_sim_creation = {}
for sim_creation in sim_creations_to_match:
for (index, household_member_data) in enumerate(filter_template_type.get_household_members()):
if index in index_to_sim_creation:
pass
if household_member_data.sim_template._sim_creation_info.age_variant is not None and sim_creation.age != household_member_data.sim_template._sim_creation_info.age_variant.min_age:
pass
possible_gender = household_member_data.sim_template._sim_creation_info.gender
if possible_gender is not None and possible_gender != sim_creation.gender:
pass
index_to_sim_creation[index] = sim_creation
while len(index_to_sim_creation) == len(sim_creations_to_match):
valid_filter_template_type.append((filter_template_type, index_to_sim_creation))
if valid_filter_template_type:
return random.choice(valid_filter_template_type)
return (None, None)
def get_career_list(self):
career_list = []
career_manager = services.get_instance_manager(sims4.resources.Types.CAREER)
for career_id in career_manager.types:
career_tuning = career_manager.get(career_id)
career_list.append(career_tuning)
return career_list
def load_away_action_info_from_proto(self, away_action_tracker_proto):
if away_action_tracker_proto.HasField('away_action'):
away_action_cls = services.get_instance_manager(sims4.resources.Types.AWAY_ACTION).get(away_action_tracker_proto.away_action.away_action_id)
if away_action_tracker_proto.away_action.HasField('target_sim_id'):
target = services.sim_info_manager().get(away_action_tracker_proto.away_action.target_sim_id)
else:
target = None
self._current_away_action = away_action_cls(self, target=target)
def _initialize_environment_score_commodities(instance_manager=None):
global environment_score_mood_commodities
if instance_manager is None:
instance_manager = services.get_instance_manager(sims4.resources.Types.MOOD)
environment_score_mood_commodities = []
for mood in instance_manager.types.values():
while mood.environment_scoring_commodity is not None:
environment_score_mood_commodities.append(mood.environment_scoring_commodity)
def load(self, statistics):
statistics_manager = services.get_instance_manager(sims4.resources.Types.STATISTIC)
for statistics_data in statistics:
stat_cls = statistics_manager.get(statistics_data.name_hash)
if stat_cls is not None:
self.set_value(stat_cls, statistics_data.value, from_load=True)
else:
logger.warn('Sim has a saved value for a statistic which is no longer defined in tuning. Discarding value.', stat_cls)
def load(self, sim_info, rel_data):
try:
track_manager = services.get_instance_manager(sims4.resources.Types.STATISTIC)
try:
self._bit_track_tracker.suppress_callback_setup_during_load = True
for track_data in rel_data.tracks:
track_type = track_manager.get(track_data.track_id)
track_inst = self._bit_track_tracker.add_statistic(track_type)
if track_inst is not None:
track_inst.set_value(track_data.value)
track_inst.update_instance_data()
track_inst.visible_to_client = track_data.visible
track_inst.fixup_callbacks_during_load()
else:
logger.warn('Failed to load track {} on sim {}. This is valid if the tuning has changed.', track_type, sim_info, owner='rez')
finally:
self._bit_track_tracker.suppress_callback_setup_during_load = False
bit_manager = services.get_instance_manager(sims4.resources.Types.RELATIONSHIP_BIT)
logger.assert_raise(bit_manager, 'Unable to retrieve relationship bit manager.')
bit_list = [bit_manager.get(bit_instance_id) for bit_instance_id in rel_data.bits]
for bit_added_buff in rel_data.bit_added_buffs:
self.bit_added_buffs[bit_added_buff.bit_id] = list(bit_added_buff.buff_ids)
while len(bit_list):
bit = bit_list.pop()
if bit is None:
logger.error('Loading None bit for sim {}.', sim_info, owner='rez')
continue
if self.has_bit(bit):
continue
while not self.add_bit(bit, False, bit_list, bit_added_buffs=self.bit_added_buffs.get(bit.guid64, None)):
logger.warn('Failed to load relationship bit {} for sim {}. This is valid if tuning has changed.', bit, sim_info)
continue
if rel_data.timeouts is not None:
for timeout_save in rel_data.timeouts:
bit = bit_manager.get(timeout_save.timeout_bit_id_hash)
timeout_data = self._find_timeout_data_by_bit(bit)
if timeout_data is not None:
self.remove_bit(bit, False)
else:
logger.warn('Attempting to load timeout value on bit {} with no timeout. This is valid if tuning has changed.', bit)
while rel_data.knowledge is not None:
self._knowledge = SimKnowledge(self)
self._knowledge.load(rel_data.knowledge)
except Exception:
logger.exception('Exception thrown while loading relationship data for Sim {}', sim_info, owner='rez')
def purchase_whim_award(self, reward_guid64):
reward_instance = services.get_instance_manager(sims4.resources.Types.REWARD).get(reward_guid64)
award = reward_instance
cost = self.SATISFACTION_STORE_ITEMS[reward_instance].cost
if self._sim_info.get_whim_bucks() < cost:
logger.debug('Attempting to purchase a whim award with insufficient funds: Cost: {}, Funds: {}', cost, self._sim_info.get_whim_bucks())
return
self._sim_info.add_whim_bucks(-cost, SetWhimBucks.PURCHASED_REWARD)
award.give_reward(self._sim_info)
def get_managers():
managers = {}
for definition in INSTANCE_TUNING_DEFINITIONS:
label = definition.TypeNames.lower()
instance_type = definition.TYPE_ENUM_VALUE
if instance_type == sims4.resources.Types.TUNING:
label = 'module_tuning'
managers[label] = services.get_instance_manager(instance_type)
return managers
def _buff_type_selection_gen(cls, target):
buff_manager = services.get_instance_manager(sims4.resources.Types.BUFF)
if cls.is_add:
for buff_type in buff_manager.types.values():
while not target.has_buff(buff_type):
yield buff_type
else:
for buff_type in target.get_active_buff_types():
yield buff_type
def give_reward(reward_name, opt_sim:server_commands.argument_helpers.OptionalTargetParam=None, _connection=None):
output = sims4.commands.Output(_connection)
reward_instance = services.get_instance_manager(sims4.resources.Types.REWARD).get(reward_name)
if reward_instance is None:
output('Failed to find the specified reward instance.')
return False
sim = server_commands.argument_helpers.get_optional_target(opt_sim, _connection)
reward_instance.give_reward(sim.sim_info)
output('Successfully gave the reward.')
def reset_milestone(self, milestone_guid):
completed_milestone = services.get_instance_manager(sims4.resources.Types.ASPIRATION).get(milestone_guid)
for objective in completed_milestone.objectives:
while objective.resettable:
objective.reset_objective(self.data_object)
self.reset_objective(objective.guid64)
self.update_objective(objective.guid64, 0, objective.goal_value(), objective.is_goal_value_money)
self._send_objectives_update_to_client()
super().reset_milestone(milestone_guid)
def get_states_and_values():
all_states = []
all_state_values = []
from objects.components.state import ObjectState, ObjectStateValue
for (_, obj) in services.get_instance_manager(sims4.resources.Types.OBJECT_STATE).types.items():
if issubclass(obj, ObjectState):
all_states.append(obj)
while issubclass(obj, ObjectStateValue):
all_state_values.append(obj)
return (all_states, all_state_values)
def force_send_data_update(self):
for aspiration in services.get_instance_manager(sims4.resources.Types.ASPIRATION).types.values():
if aspiration.disabled:
pass
if aspiration.aspiration_type() != AspriationType.FULL_ASPIRATION:
pass
for objective in aspiration.objectives:
self.update_objective(objective.guid64, 0, objective.goal_value(), objective.is_goal_value_money, from_init=True)
self._tracker_dirty = True
self.send_if_dirty()
def _compute_environment_score(self, sim=None, ignore_disabled_state=False):
object_mood_modifiers = {}
negative_modifiers = (0, 1)
positive_modifiers = (0, 1)
contributions = []
gsi_enabled = sim is not None and gsi_handlers.sim_handlers_log.environment_score_archiver.enabled
if sim is not None:
trait_tracker = sim.sim_info.trait_tracker
else:
trait_tracker = None
if trait_tracker is not None:
for (trait, trait_modifiers) in self.owner.environment_score_trait_modifiers.items():
while trait in trait_tracker.equipped_traits:
(object_mood_modifiers, negative_modifiers, positive_modifiers) = trait_modifiers.combine_modifiers(object_mood_modifiers, negative_modifiers, positive_modifiers)
if gsi_enabled:
contributions.extend(gsi_handlers.sim_handlers_log.get_environment_score_object_contributions(self.owner, 'Trait: {} on Object:{}'.format(trait.__name__, gsi_handlers.gsi_utils.format_object_name(self.owner)), trait_modifiers))
for state in self._state_environment_scores:
while not (ignore_disabled_state and state.state_value is EnvironmentScoreTuning.DISABLED_STATE_VALUE):
if state.state_value is EnvironmentScoreTuning.ENABLED_STATE_VALUE:
pass
value_base_modifiers = state.base_modifiers
(object_mood_modifiers, negative_modifiers, positive_modifiers) = value_base_modifiers.combine_modifiers(object_mood_modifiers, negative_modifiers, positive_modifiers)
if gsi_enabled:
contributions.extend(gsi_handlers.sim_handlers_log.get_environment_score_object_contributions(self.owner, 'State Value: ' + state.state_value.__name__, value_base_modifiers))
while trait_tracker is not None:
while True:
for (trait, state_trait_modifiers) in state.trait_modifiers.items():
while trait in trait_tracker.equipped_traits:
(object_mood_modifiers, negative_modifiers, positive_modifiers) = state_trait_modifiers.combine_modifiers(object_mood_modifiers, negative_modifiers, positive_modifiers)
if gsi_enabled:
contributions.extend(gsi_handlers.sim_handlers_log.get_environment_score_object_contributions(self.owner, 'Trait: {} in State Value: {}'.format(trait.__name__, state.state_value.__name__), state_trait_modifiers))
mood_scores = {}
instance_manager = services.get_instance_manager(sims4.resources.Types.MOOD)
for mood in instance_manager.types.values():
if ignore_disabled_state or self.is_mood_scoring_enabled():
mood_score = self._environment_scores.get(mood, 0)
current_mood_score = mood_scores.get(mood, 0)
if gsi_enabled and mood_score != 0:
contributions.append({'object': gsi_handlers.gsi_utils.format_object_name(self.owner), 'object_id': self.owner.id, 'source': 'Definition : ' + self.owner.definition.name, 'score_affected': mood.__name__, 'adder': mood_score, 'multiplier': 1})
mood_modifiers = object_mood_modifiers.get(mood)
if mood_modifiers is not None:
(adder, multiplier) = mood_modifiers
current_mood_score = current_mood_score + (mood_score + adder)*multiplier
else:
current_mood_score = current_mood_score + mood_score
else:
current_mood_score = 0
mood_scores[mood] = current_mood_score
if gsi_enabled and self._negative_environment_score != 0:
contributions.append({'object': gsi_handlers.gsi_utils.format_object_name(self.owner), 'object_id': self.owner.id, 'source': 'Definition : ' + self.owner.definition.name, 'score_affected': 'NEGATIVE SCORING', 'adder': self._negative_environment_score, 'multiplier': 1})
if gsi_enabled and self._positive_environment_score != 0:
contributions.append({'object': gsi_handlers.gsi_utils.format_object_name(self.owner), 'object_id': self.owner.id, 'source': 'Definition : ' + self.owner.definition.name, 'score_affected': 'POSITIVE SCORING', 'adder': self._positive_environment_score, 'multiplier': 1})
negative_score = (self._negative_environment_score + negative_modifiers[0])*negative_modifiers[1]
positive_score = (self._positive_environment_score + positive_modifiers[0])*positive_modifiers[1]
return (mood_scores, negative_score, positive_score, contributions)
def load(self, load_list):
try:
for (stat_type_name, value) in load_list:
stat_cls = services.get_instance_manager(sims4.resources.Types.STATISTIC).get(stat_type_name)
while stat_cls is not None:
if stat_cls.persisted:
self.set_value(stat_cls, value)
else:
logger.warn('Object has a saved value for {}, which is not a persisted statistic. Discarding value.', stat_cls)
except ValueError:
logger.error('Attempting to load old data in BaseStatisticTracker.load()')
def load_unlock(self, unlock_proto_msg):
for unlock_data in unlock_proto_msg.unlock_data_list:
instance_id = unlock_data.unlock_instance_id
instance_type = unlock_data.unlock_instance_type
manager = services.get_instance_manager(instance_type)
if manager is None:
logger.error('Loading: Sim {} fail to get instance manager for unlock item {}, type {}', self.owner, instance_id, instance_type, owner='cjiang')
tuning_class = manager.get(instance_id)
if tuning_class is None:
logger.error('Loading: Sim {} fail to get class for unlock item {}, type {}', self.owner, instance_id, instance_type, owner='cjiang')
self._unlocks.append(Unlock(tuning_class, unlock_data.custom_name))
def get_zones_for_venue_type(self, venue_type):
possible_zones = []
venue_manager = services.get_instance_manager(sims4.resources.Types.VENUE)
for neighborhood_proto in services.get_persistence_service().get_neighborhoods_proto_buf_gen():
for lot_owner_info in neighborhood_proto.lots:
zone_id = lot_owner_info.zone_instance_id
while zone_id is not None:
venue_type_id = build_buy.get_current_venue(zone_id)
if venue_manager.get(venue_type_id) is venue_type:
possible_zones.append(lot_owner_info.zone_instance_id)
return possible_zones
class OwnableComponent(Component, HasTunableFactory, component_name=types.OWNABLE_COMPONENT, persistence_key=protocols.PersistenceMaster.PersistableData.OwnableComponent):
DEFAULT_OWNABLE_COMPONENT_AFFORDANCES = TunableList(TunableReference(manager=services.get_instance_manager(sims4.resources.Types.INTERACTION)), description='Affordances that all ownable component owners have.')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._sim_owner_id = None
def update_sim_ownership(self, new_sim_id):
self._sim_owner_id = new_sim_id
@componentmethod_with_fallback(lambda : None)
def get_sim_owner_id(self):
return self._sim_owner_id
def save(self, persistence_master_message):
if self._sim_owner_id is None:
return
persistable_data = protocols.PersistenceMaster.PersistableData()
persistable_data.type = protocols.PersistenceMaster.PersistableData.OwnableComponent
ownable_component_data = persistable_data.Extensions[protocols.PersistableOwnableComponent.persistable_data]
if self._sim_owner_id is not None:
ownable_component_data.sim_owner_id = self._sim_owner_id
persistence_master_message.data.extend([persistable_data])
def _owning_sim_in_owning_household(self, sim_id):
owner_household_id = self.owner.get_household_owner_id()
if sim_id is None or owner_household_id is None:
return False
household = services.household_manager().get(owner_household_id)
if household is None:
return False
return household.sim_in_household(sim_id)
def _on_households_loaded_verify(self):
if not self._owning_sim_in_owning_household(self._sim_owner_id):
self._sim_owner_id = None
else:
self.owner.update_object_tooltip()
def load(self, persistable_data):
ownable_component_data = persistable_data.Extensions[protocols.PersistableOwnableComponent.persistable_data]
if ownable_component_data.HasField('sim_owner_id'):
self._sim_owner_id = ownable_component_data.sim_owner_id
services.current_zone().register_callback(zone_types.ZoneState.HOUSEHOLDS_AND_SIM_INFOS_LOADED, self._on_households_loaded_verify)
def component_super_affordances_gen(self, **kwargs):
for affordance in self.DEFAULT_OWNABLE_COMPONENT_AFFORDANCES:
yield affordance
def __init__(self, prior_open_street_director_proto=None):
self._active = False
self._active_open_street_director_request = None
self._open_street_director_requests = []
for _ in range(len(OpenStreetDirectorPriority)):
self._open_street_director_requests.append([])
self._prior_open_street_director_proto = prior_open_street_director_proto
if self._prior_open_street_director_proto is not None:
conditional_layer_manager = services.get_instance_manager(sims4.resources.Types.CONDITIONAL_LAYER)
conditional_layers = conditional_layer_manager.types.values()
for layer in self._prior_open_street_director_proto.loaded_layers:
for conditional_layer in conditional_layers:
if layer == conditional_layer.layer_name:
self._prior_open_street_director_proto.loaded_layer_guids.append(conditional_layer.guid64)
break
del self._prior_open_street_director_proto.loaded_layers[:]
def __init__(self, asm_source=None):
if asm_source is not None:
source_query = SourceQueries.ASMActorObject
else:
source_query = None
super().__init__(actor_name=Tunable(str,
None,
source_location=asm_source,
source_query=source_query),
parent_name=Tunable(str,
'surface',
source_location=asm_source,
source_query=source_query),
slot_type=TunableReference(
services.get_instance_manager(
sims4.resources.Types.SLOT_TYPE)))
def load_away_action_info_from_proto(self, away_action_tracker_proto):
if away_action_tracker_proto.HasField('away_action'):
away_action_cls = services.get_instance_manager(
sims4.resources.Types.AWAY_ACTION).get(
away_action_tracker_proto.away_action.away_action_id)
if away_action_cls is None:
logger.error(
'Failed to load away action id {}',
away_action_tracker_proto.away_action.away_action_id)
return
if away_action_tracker_proto.away_action.HasField('target_sim_id'):
target = services.sim_info_manager().get(
away_action_tracker_proto.away_action.target_sim_id)
else:
target = None
self._current_away_action = away_action_cls(self, target=target)
def get_outfit_tags(self):
outfit_tags = set()
situation_manager = services.get_instance_manager(sims4.resources.Types.SITUATION)
for situation in situation_manager.types.values():
if self.situation_tags:
if any(tag in situation.tags for tag in self.situation_tags):
for situation_job in situation.get_tuned_jobs():
if situation_job.job_uniform is None:
continue
outfit_generators = situation_job.job_uniform.situation_outfit_generators
if outfit_generators is None:
continue
for entry in outfit_generators:
for tag in entry.generator.tags:
outfit_tags.add(tag)
return outfit_tags
class _TestRecipeByDefinition(HasTunableSingletonFactory, AutoFactoryInit):
FACTORY_TUNABLES = {
'valid_recipes':
TunableSet(description=
'\n The set of recipes allowed.\n ',
tunable=TunableReference(
manager=services.get_instance_manager(Types.RECIPE),
class_restrictions=('Recipe', )),
minlength=1)
}
def test_recipe(self, recipe):
if recipe not in self.valid_recipes:
return TestResult(
False, f'{recipe} not in valid recipes {self.valid_recipes}')
return TestResult.TRUE
def generate_drama_tuning_data(zone_id: int = None, filter=None):
all_nodes = []
filter_list = parse_filter_to_list(filter)
dnm = services.get_instance_manager(sims4.resources.Types.DRAMA_NODE)
for node_type in dnm.types.values():
node_data = {}
node_name = node_type.__name__
if drama_node_string_matches_filters(node_name, filter_list):
node_data['drama_node_name'] = node_name
valid_time_strings = node_type.get_debug_valid_time_strings()
for (day, valid_hours) in valid_time_strings.items():
day_name = day.name.lower()
time_string = ','.join(valid_hours)
node_data[day_name] = time_string
all_nodes.append(node_data)
return all_nodes
def __init__(self, *args, **kwargs):
super().__init__(
statistic=TunableReference(
description=
'\n The statistic to be changed on the object.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.STATISTIC)),
amount=TunableVariant(
constant=ConstantAmount(),
statistic_based=StatisticBased(),
description=
'\n The amount to modify the statistic by.\n '
),
description=
'\n Modify the statistic value of an object.\n '
)
def _show_away_notification(self):
if self.away_notification is None:
return
zone_data = services.get_persistence_service().get_zone_proto_buff(
self._zone_id)
if zone_data is None:
return
venue_tuning_id = build_buy.get_current_venue(self._zone_id)
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(venue_tuning_id)
if venue_tuning is None:
return
dialog = self.away_notification(services.active_sim_info())
dialog.show_dialog(additional_tokens=(zone_data.name,
venue_tuning.display_name))
class BroadcasterEffectLoot(_BroadcasterEffectTestedOneShot):
FACTORY_TUNABLES = {
'loot_list':
TunableList(description=
'\n A list of loot operations.\n ',
tunable=TunableReference(
manager=services.get_instance_manager(
sims4.resources.Types.ACTION),
class_restrictions=('LootActions', ),
pack_safe=True))
}
def _apply_broadcaster_effect(self, broadcaster, affected_object):
resolver = broadcaster.get_resolver(affected_object)
for loot_action in self.loot_list:
loot_action.apply_to_resolver(resolver)
def _scholarship_container_helper(scholarships_of_status, sim_info,
tooltip):
snippet_manager = services.get_instance_manager(
sims4.resources.Types.SNIPPET)
scholarship_insts_of_status = [
snippet_manager.get(scholarship)
for scholarship in scholarships_of_status
]
if not self._scholarships.test_collection(
scholarship_insts_of_status):
return TestResult(
False,
"{0}'s scholarships do not match the tuned whitelist/blacklist.",
sim_info,
tooltip=tooltip)
return TestResult.TRUE
class SituationSimsPickerMixin:
INSTANCE_TUNABLES = {
'valid_situations':
SituationSearchByDefinitionOrTagsVariant(
description=
'\n Situations where the guest list will be collected to populate the picker.\n ',
tuning_group=GroupNames.PICKERTUNING),
'job_filter':
TunableList(
description=
'\n If provided, only looks for Sims with the specified jobs.\n ',
tunable=TunablePackSafeReference(
manager=services.get_instance_manager(
sims4.resources.Types.SITUATION_JOB)),
tuning_group=GroupNames.PICKERTUNING)
}
REMOVE_INSTANCE_TUNABLES = ('sim_filter', 'sim_filter_household_override',
'sim_filter_requesting_sim',
'include_uninstantiated_sims',
'include_instantiated_sims',
'include_actor_sim', 'include_target_sim')
@flexmethod
def _get_valid_sim_choices_gen(cls, inst, target, context, **kwargs):
inst_or_cls = inst if inst is not None else cls
for situation in cls.valid_situations.get_all_matching_situations():
for sim in situation.all_sims_in_situation_gen():
if not not cls.job_filter and situation.get_current_job_for_sim(
sim) not in cls.job_filter:
continue
if inst_or_cls.sim_tests:
if inst:
interaction_parameters = inst.interaction_parameters.copy(
)
else:
interaction_parameters = kwargs.copy()
interaction_parameters['picked_item_ids'] = {sim.sim_id}
resolver = InteractionResolver(cls,
inst,
target=target,
context=context,
**interaction_parameters)
if inst_or_cls.sim_tests.run_tests(resolver):
yield FilterResult(sim_info=sim.sim_info)
yield FilterResult(sim_info=sim.sim_info)
else:
yield FilterResult(sim_info=sim.sim_info)
def __init__(self,
target_default=ParticipantType.Object,
carry_target_default=ParticipantType.Object,
locked_args=None,
class_restrictions=(),
**kwargs):
super().__init__(tunable=TunableTuple(
description=
'\n Tunables related to a specific affordance we are providing,\n with the ability to override specifics about targets,\n restrictions, and dependencies.\n ',
affordance=TunableReference(
description=
'\n An affordance we make available. Pay attention to who this\n affordance is provided on. See the provided affordances\n description for more info.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.INTERACTION),
class_restrictions=class_restrictions,
pack_safe=True),
target=TunableEnumEntry(
description=
'\n The participant the affordance will target. See the\n provided affordances description for more info.\n ',
tunable_type=ParticipantType,
default=target_default),
carry_target=TunableEnumEntry(
description=
'\n The participant the affordance will set as a carry target.\n ',
tunable_type=ParticipantType,
default=carry_target_default),
allow_self=Tunable(
description=
'\n If set, the Sim running the providing interaction is\n allowed to also run the provided interaction.\n ',
tunable_type=bool,
default=False),
is_linked=Tunable(
description=
'\n When set to True if the original affordance is canceled,\n the provided affordance will be as well. \n \n If set to False then canceling the original affordance \n will not affect the provided affordance.\n ',
tunable_type=bool,
default=True),
unlink_if_running=Tunable(
description=
'\n If checked, the provided interaction is not canceled if the\n interaction it depends on is canceled after the provided\n interaction has already started transitioning.\n \n This is useful if it is expected for the provided\n interaction to cancel the providing one (but we want to\n preserve the linked cancelation behavior in the queue.)\n \n e.g.: Sit on Toddler Bed provides Tuck In. Tuck In\n transitions the toddler from Sit to Relax (canceling Sit).\n We want the Tuck In to complete once the transition has\n started.\n ',
tunable_type=bool,
default=False),
object_filter=TunableObjectFilterVariant(
description=
'\n Define the type of objects this affordance is provided on.\n '
),
locked_args=locked_args if locked_args is not None else {}),
**kwargs)
def generate_sim_whimset_view_data(sim_id: int = None):
whimset_view_data = []
sim_info_manager = services.sim_info_manager()
if sim_info_manager is not None:
for sim_info in sim_info_manager.objects:
while sim_info.sim_id == sim_id:
whim_tracker = sim_info._whim_tracker
whim_set_list = []
for whim_set in services.get_instance_manager(
sims4.resources.Types.ASPIRATION).all_whim_sets:
priority = whim_tracker.get_priority(whim_set)
whim_set_list.append((priority, whim_set))
whim_set_list = sorted(whim_set_list,
key=lambda whim_set: whim_set[0])
whim_set_list.reverse()
if whim_set_list is not None:
for whim_set_data in whim_set_list:
whim_set = whim_set_data[1]
whims_in_set_str = ', '.join(
whim.goal.__name__ for whim in whim_set.whims)
time_left = ''
if whim_set in whim_tracker.alarm_handles:
time_left = str(
whim_tracker.alarm_handles[whim_set].
get_remaining_time())
whim_set_entry = {
'simId':
sim_id,
'whimset':
whim_set.__name__,
'priority':
whim_tracker.get_priority(whim_set),
'target':
str(whim_tracker.get_whimset_target(whim_set)),
'base_priority':
whim_set.base_priority,
'active_priority':
whim_set.activated_priority,
'chained_priority':
whim_set.chained_priority,
'time_left':
time_left,
'whims_in_set':
whims_in_set_str
}
whimset_view_data.append(whim_set_entry)
return whimset_view_data
def recommend_order_for_table(sim_orders: str, _connection=None):
zone_director = get_restaurant_zone_director()
if zone_director is None:
sims4.commands.output('Current venue is not restaurant', _connection)
return False
proto = Restaurant_pb2.SimOrders()
text_format.Merge(sim_orders, proto)
orders = [(order.sim_id, order.recipe_id) for order in proto.sim_orders]
sims_in_order = set([
services.object_manager().get(order_sim_id)
for order_sim_id in [order[0] for order in orders]
])
for sim in sims_in_order:
if sim is None:
sims4.commands.output(
"Trying to target order for a Sim that isn't on the lot",
_connection)
return False
active_group_order = _get_active_group_order_for_dining_group(sim)
if active_group_order:
recipe_manager = services.get_instance_manager(
sims4.resources.Types.RECIPE)
for order in orders:
recipe = recipe_manager.get(order[1])
recipes = GroupOrder.get_food_drink_recipe_id_tuple(recipe)
active_group_order.add_sim_order(
order[0],
food_recipe_id=recipes[0],
drink_recipe_id=recipes[1],
recommendation_state=OrderRecommendationState.
RECOMMENDATION_PROPOSAL,
order_status=OrderStatus.ORDER_INIT)
else:
zone_director.order_for_table(
orders,
send_order=False,
recommendation_state=OrderRecommendationState.
RECOMMENDATION_PROPOSAL,
order_status=OrderStatus.ORDER_INIT)
groups = zone_director.get_dining_groups_by_sim(sim)
group = groups.pop()
group.hold_ordered_cost(
proto.meal_cost if has_field(proto, 'meal_cost') else 0)
for sim in sims_in_order:
zone_director.trigger_recommendation_interaction(
services.get_active_sim(), sim)
return True
class GameElementJoin(ParentElement, HasTunableFactory, AutoFactoryInit):
FACTORY_TUNABLES = {
'game_type':
GameRules.TunableReference(
description=
'\n The game to create or join.\n '),
'game_affordances':
TunableList(
description=
'\n Any affordance in this list, when pushed as a continuation of this\n interaction, will preserve the game, as if the Sim never left it.\n ',
tunable=TunableReference(
description=
'\n An affordance that, when pushed as a continuation of this\n interaction, preserves the game.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.INTERACTION),
class_restrictions='SuperInteraction')),
'ensure_setup':
Tunable(
description=
'\n If checked, ensure that the game is properly set up on join.\n ',
tunable_type=bool,
default=False)
}
def __init__(self, interaction, *args, sequence=(), **kwargs):
super().__init__(*args, **kwargs)
self.interaction = interaction
self.sequence = sequence
@classmethod
def on_affordance_loaded_callback(cls,
affordance,
game_join_element,
object_tuning_id=DEFAULT):
affordance.add_additional_basic_liability(
lambda *args, **kwargs: GameTransitionLiability(
*args, game_type=game_join_element.game_type, **kwargs))
def _begin_game(self, _):
self.interaction.add_liability(
_GameElementJoinLiability.LIABILITY_TOKEN,
_GameElementJoinLiability(self))
return True
def _run(self, timeline):
child_element = build_element((self._begin_game, self.sequence))
return timeline.run_child(child_element)
class CustomStatesSituationReplaceSituation(HasTunableSingletonFactory,
AutoFactoryInit):
FACTORY_TUNABLES = {
'new_situation':
TunableReference(
description=
'\n The new situation to be created.\n \n This situation will be created using the default guest list (predefined if the situation has one else an\n empty one) and non-user facing. If we want either Sims transferred between this situation and the next one\n or the following situation to be user facing GPE would just need to add new tuning within this factory to\n add the logic.\n ',
manager=services.get_instance_manager(Types.SITUATION))
}
def __call__(self, situation_state):
situation_state.owner._self_destruct()
guest_list = self.new_situation.get_predefined_guest_list()
if guest_list is None:
guest_list = SituationGuestList(invite_only=True)
services.get_zone_situation_manager().create_situation(
self.new_situation, guest_list=guest_list, user_facing=False)
class TrackCommodity(HasTunableFactory, AutoFactoryInit):
FACTORY_TUNABLES = {
'commodity_to_track':
TunableReference(
description=
'\n The commodity that we want to track on the Sim.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.STATISTIC),
class_restrictions=('Commodity', )),
'threshold':
TunableThreshold(
description=
'\n The threshold that we are trying to reach.\n '
)
}
def __init__(self, event_data_tracker, milestone, objective, **kwargs):
super().__init__(**kwargs)
self._event_data_tracker = event_data_tracker
self._owning_milestone = milestone
self._owning_objective = objective
self._commodity_tracker_handle = None
def on_threshold_reached(self, stat_type):
self._event_data_tracker.tracker_complete(self._owning_milestone,
self._owning_objective)
def setup(self):
sim_info = self._event_data_tracker.owner_sim_info
if sim_info is None:
return False
if self._commodity_tracker_handle is not None:
self._commodity_tracker_handle = sim_info.commodity_tracker.create_and_add_listener(
self.commodity_to_track, self.threshold,
self.on_threshold_reached)
return True
def clear(self):
if self._commodity_tracker_handle is not None:
sim_info = self._event_data_tracker.owner_sim_info
sim_info.commodity_tracker.remove_listener(
self._commodity_tracker_handle)
self._commodity_tracker_handle = None
self._event_data_tracker = None
self._owning_milestone = None
self._owning_objective = None
def _get_university_organization_requirement_filter_terms(
config_data, filter_terms=[]):
organization_id = UniversityUtils._get_university_organization_id_from_configuration(
config_data)
if organization_id is None:
return
snippet_manager = services.get_instance_manager(
sims4.resources.Types.SNIPPET)
organization = snippet_manager.get(organization_id)
if organization is None:
return
criteria = UniversityHousingRoommateRequirementCriteria.ORGANIZATION
ranked_statistic_filter_term = UniversityHousingTuning.UNIVERSITY_HOUSING_ROOMMATE_FILTER_TERM_TEMPLATES[
criteria]
ranked_statistic_filter_term.set_ranked_statistic(
organization.progress_statistic)
filter_terms.append(ranked_statistic_filter_term)
def _trait_selection_gen(cls, target):
trait_manager = services.get_instance_manager(
sims4.resources.Types.TRAIT)
trait_tracker = target.sim_info.trait_tracker
if cls.is_add:
for trait in trait_manager.types.values():
if not cls._match_trait_type(trait):
continue
if trait.sim_info_fixup_actions:
continue
if trait_tracker.can_add_trait(trait):
yield trait
else:
for trait in trait_tracker.equipped_traits:
if not cls._match_trait_type(trait):
continue
yield trait
class VocalTrack(HasTunableReference,
metaclass=HashedTunedInstanceMetaclass,
manager=services.get_instance_manager(
sims4.resources.Types.RECIPE)):
INSTANCE_TUNABLES = {
'vocal_clip':
TunableResourceKey(
description=
'\n The propx file of the vox to play.\n ',
default=None,
resource_types=(sims4.resources.Types.PROPX, )),
'tests':
TunableTestSet(
description=
'\n Tests to verify if this song is available for the Sim to play.\n '
)
}
def __init__(
self,
description='Join a game as part of this interaction, and leave it when the interaction finishes.',
**kwargs):
super().__init__(
game=TunableReference(
description=
'\n A reference to the game created when this interaction is run.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.GAME_RULESET)),
ensure_setup=Tunable(
description=
'\n Tunable that, when checked, will make sure the game gets setup.\n ',
tunable_type=bool,
default=False),
description=description,
**kwargs)
class SituationGoalLootActions(HasTunableReference,
metaclass=TunedInstanceMetaclass,
manager=services.get_instance_manager(
sims4.resources.Types.ACTION)):
INSTANCE_TUNABLES = {
'goal_loot_actions':
TunableList(
TunableVariant(statistics=TunableStatisticChange(
locked_args={
'subject': ParticipantType.Actor,
'advertise': False,
'chance': SuccessChance.ONE
}),
money_loot=MoneyChange.TunableFactory(
locked_args={
'subject': ParticipantType.Actor,
'chance': SuccessChance.ONE,
'display_to_user': None,
'statistic_multipliers': None
}),
buff=buffs.buff_ops.BuffOp.TunableFactory(
locked_args={
'subject': ParticipantType.Actor,
'chance': SuccessChance.ONE
}),
notification_and_dialog=DialogLootOp.TunableFactory(
locked_args={
'subject': ParticipantType.Actor,
'advertise': False,
'chance': SuccessChance.ONE
}),
reaction=ReactionLootOp.TunableFactory(
locked_args={
'subject': ParticipantType.Actor,
'advertise': False,
'chance': SuccessChance.ONE
}),
state_change=StateChangeLootOp.TunableFactory(
locked_args={
'advertise': False,
'chance': SuccessChance.ONE
})))
}
def __iter__(self):
return iter(self.goal_loot_actions)
def load(self, zone_data=None):
save_slot_data = services.get_persistence_service(
).get_save_slot_proto_buff()
msg = save_slot_data.gameplay_data.holiday_service
holiday_manager = services.get_instance_manager(
sims4.resources.Types.HOLIDAY_DEFINITION)
for custom_holiday_msg in msg.holidays:
holiday_type = holiday_manager.get(custom_holiday_msg.holiday_type)
custom_holiday = CustomHoliday(custom_holiday_msg.holiday_type,
holiday_type)
custom_holiday.load_holiday(custom_holiday_msg)
self._holidays[custom_holiday.holiday_id] = custom_holiday
for holiday_calendar in msg.calendars:
calendar_length = SeasonLength(holiday_calendar.season_length)
self._holiday_times[calendar_length] = YearOfHolidays(
calendar_length)
self._holiday_times[calendar_length].load(holiday_calendar)
def load(self, load_list):
try:
for (stat_type_name, value) in load_list:
stat_cls = services.get_instance_manager(
sims4.resources.Types.STATISTIC).get(stat_type_name)
if stat_cls is not None:
if self._sim_info.lod >= stat_cls.min_lod_value:
if stat_cls.persisted:
self.set_value(stat_cls, value)
else:
logger.info(
'Trying to load unavailable STATISTIC resource: {}',
stat_type_name)
except ValueError:
logger.error(
'Attempting to load old data in BaseStatisticTracker.load()')
self.check_for_unneeded_initial_statistics()
def print_relationship_score(source_sim_id: int,
target_sim_id: int,
track_name,
_connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
track_type = services.get_instance_manager(
sims4.resources.Types.STATISTIC).get(track_name)
if track_type is None:
sims4.commands.output(
'Invalid relationship track: {0}'.format(track_name), _connection)
return False
score = source_sim_info.relationship_tracker.get_relationship_score(
target_sim_id, track_type)
sims4.commands.output('Relationship Score: {0}'.format(score), _connection)
return True
class _loot_only(_dialog_and_loot):
FACTORY_TUNABLES = {
'on_drama_node_run_loot':
TunableList(
description=
'\n A list of loot operations to apply when the drama node runs.\n ',
tunable=TunableReference(manager=services.get_instance_manager(
sims4.resources.Types.ACTION),
class_restrictions=('LootActions',
'RandomWeightedLoot'),
pack_safe=True))
}
def on_node_run(self, drama_node):
resolver = drama_node._get_resolver()
for loot_action in self.on_drama_node_run_loot:
loot_action.apply_to_resolver(resolver)
class ScheduleDramaNodeLoot(BaseLootOperation):
FACTORY_TUNABLES = {
'drama_node':
TunableReference(
description=
'\n The drama node to schedule.\n ',
manager=services.get_instance_manager(
sims4.resources.Types.DRAMA_NODE))
}
def __init__(self, drama_node, **kwargs):
super().__init__(**kwargs)
self._drama_node = drama_node
def _apply_to_subject_and_target(self, subject, target, resolver):
services.drama_scheduler_service().schedule_node(
self._drama_node, resolver)
def show_club_gathering_dialog(
self,
sim_info,
*,
flavor_text,
start_source=ClubGatheringStartSource.DEFAULT,
sender_sim_info=DEFAULT):
zone_id = self.get_hangout_zone_id()
if not zone_id:
return False
current_region = services.current_region()
hangout_region = get_region_instance_from_zone_id(zone_id)
if not current_region.is_region_compatible(hangout_region):
return False
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_tuning = venue_manager.get(build_buy.get_current_venue(zone_id))
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)
zone_data = services.get_persistence_service().get_zone_proto_buff(
zone_id)
lot_name = zone_data.name
sender_sim_info = self.leader if sender_sim_info is DEFAULT else sender_sim_info
flavor_text = flavor_text(sim_info, sender_sim_info, self)
additional_tokens = (lot_name, venue_tuning.club_gathering_text(),
flavor_text)
self.show_club_notification(sim_info,
ClubTunables.CLUB_GATHERING_DIALOG,
target_sim_id=sender_sim_info.sim_id,
additional_tokens=additional_tokens,
on_response=on_response)
def __init__(self, zone_data, **kwargs):
super().__init__(**kwargs)
self.zone_id = zone_data.zone_id
self.name = zone_data.name
self.world_id = zone_data.world_id
self.lot_template_id = zone_data.lot_template_id
self.lot_description_id = zone_data.lot_description_id
venue_manager = services.get_instance_manager(
sims4.resources.Types.VENUE)
venue_type_id = build_buy.get_current_venue(zone_data.zone_id)
if venue_type_id is not None:
venue_type = venue_manager.get(venue_type_id)
if venue_type is not None:
self.venue_type_name = venue_type.display_name
householdProto = services.get_persistence_service(
).get_household_proto_buff(zone_data.household_id)
self.household_name = householdProto.name if householdProto is not None else None
