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 npc_order_food_at_chef_station(opt_sim: OptionalTargetParam = None,
chef_sim: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output("Sim {} doesn't exist.".format(opt_sim),
_connection)
return False
chef_sim = get_optional_target(chef_sim, _connection)
if chef_sim is None:
sims4.commands.output("Chef {} doesn't exist.".format(chef_sim),
_connection)
return False
chef_situation = restaurant_utils.get_chef_situation(chef_sim=chef_sim)
if chef_situation is None:
sims4.commands.output("Couldn't find a Chef Situation in this zone.")
return False
if chef_situation.menu_preset is not None:
food_order = ChefsChoice.get_order_for_npc_sim_with_menu(
sim, chef_situation.menu_preset)
else:
(food_order, _) = ChefsChoice.get_order_for_npc_sim(sim)
chef_situation.add_direct_order(food_order, sim)
services.get_event_manager().process_event(
test_events.TestEvent.RestaurantFoodOrdered, sim_info=sim.sim_info)
return True
def give_chef_feedback(to_chef_sim_id: OptionalTargetParam = None,
from_sim_id: OptionalTargetParam = None,
is_compliment: bool = True,
waitstaff_sim_id: OptionalTargetParam = None,
_connection=None):
from_sim = get_optional_target(from_sim_id, _connection)
if from_sim is None:
sims4.commands.output("From Sim {} doesn't exist.".format(from_sim_id),
_connection)
return False
to_chef_sim = get_optional_target(to_chef_sim_id, _connection)
if to_chef_sim is None:
sims4.commands.output(
"To Chef Sim {} doesn't exist.".format(to_chef_sim_id),
_connection)
return False
waitstaff_sim = get_optional_target(waitstaff_sim_id, _connection)
if waitstaff_sim is None:
sims4.commands.output(
"Waitstaff Sim {} doesn't exist.".format(waitstaff_sim_id),
_connection)
return False
waitstaff_situation = restaurant_utils.get_waitstaff_situation(
waitstaff_sim)
waitstaff_situation.give_chef_feedback(to_chef_sim, from_sim,
is_compliment)
def pregnancy_roll_traits(parent_sim_a: OptionalSimInfoParam = None,
parent_sim_b: OptionalSimInfoParam = None,
num_traits: int = DEFAULT,
offspring_gender: Gender = Gender.FEMALE,
_connection=None):
output = sims4.commands.Output(_connection)
parent_a = get_optional_target(parent_sim_a,
_connection,
target_type=OptionalSimInfoParam)
parent_b = get_optional_target(parent_sim_b,
_connection,
target_type=OptionalSimInfoParam)
if not (parent_a and parent_b):
output('Invalid parents!')
return False
if parent_a.gender is parent_b.gender:
output('Both parents have same gender.')
return False
species = parent_a.species
aging_data = AgingTuning.get_aging_data(species)
age = aging_data.get_birth_age()
if num_traits is DEFAULT:
num_traits = aging_data.get_personality_trait_count(age)
offspring_data = PregnancyOffspringData(age, offspring_gender,
parent_a.species, parent_sim_a, 1)
selected_traits = PregnancyTracker.select_traits_for_offspring(
offspring_data, parent_a, parent_b, num_traits)
output('Selected Personality Traits:\n\t{}'.format('\n\t'.join(
str(trait) for trait in selected_traits
if trait.is_personality_trait)))
def claim_table(opt_sim: OptionalTargetParam = None,
opt_table: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output("Sim {} doesn't exist".format(opt_sim),
_connection)
return False
table_to_claim = get_optional_target(opt_table, _connection)
zone_director = get_restaurant_zone_director()
if zone_director is None:
sims4.commands.output('Current venue is not restaurant', _connection)
return False
zone_director.claim_table(sim, table_to_claim)
def create_new_crime_data(opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
career = next(iter(sim_info.career_tracker.careers.values()))
career.create_new_crime_data()
def broadcasters_add(broadcaster_type, broadcasting_object:OptionalTargetParam=None, _connection=None):
broadcasting_object = get_optional_target(broadcasting_object, _connection)
if broadcasting_object is None:
return False
broadcaster = broadcaster_type(broadcasting_object=broadcasting_object)
services.current_zone().broadcaster_service.add_broadcaster(broadcaster)
return True
def test_ping_autonomy(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No target for autonomy.run', _connection)
return
selected_interaction = sim.run_test_autonomy_ping()
sims4.commands.output('Autonomy Test Ping: {}'.format(selected_interaction), _connection)
def add_statistic_to_tracker(stat_type, opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is not None and stat_type is not None:
tracker = target.get_tracker(stat_type)
tracker.add_statistic(stat_type)
else:
sims4.commands.output('No target for stats.add_stat_to_tracker. Params: stat_name, optional target', _connection)
def travel_sims_to_zone(opt_sim_id:OptionalTargetParam, zone_id:int, *traveling_sim_ids, _connection=None):
sim_or_sim_info = get_optional_target(opt_sim_id, _connection)
if sim_or_sim_info is None:
if opt_sim_id:
sim_or_sim_info = services.sim_info_manager().get(opt_sim_id)
if sim_or_sim_info is None:
sims4.commands.output('Invalid Sim id: {} specified for travel.travel_sims_to_zone'.format(opt_sim_id), _connection)
return False
else:
sims4.commands.output('No Sim id specified for travel.travel_sims_to_zone', _connection)
return False
zone_proto_buff = services.get_persistence_service().get_zone_proto_buff(zone_id)
if zone_proto_buff is None:
sims4.commands.output('Invalid Zone Id: {}. Zone does not exist.'.format(zone_id), _connection)
return False
situation_manager = services.get_zone_situation_manager()
situation = situation_manager.DEFAULT_TRAVEL_SITUATION
guest_list = situation.get_predefined_guest_list()
if guest_list is None:
guest_list = SituationGuestList(invite_only=True, host_sim_id=sim_or_sim_info.id)
default_job = situation.default_job()
sim_info_manager = services.sim_info_manager()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
traveling_sim_ids = tuple(itertools.chain(traveling_sim_ids, (sim_info.sim_id for sim_info in roommate_service.get_auto_invite_sim_infos(sim_or_sim_info, situation))))
for sim_id in traveling_sim_ids:
sim_id = int(sim_id)
sim_info = sim_info_manager.get(sim_id)
if sim_info is None:
continue
guest_info = SituationGuestInfo.construct_from_purpose(sim_id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
guest_info = SituationGuestInfo.construct_from_purpose(sim_or_sim_info.id, default_job, SituationInvitationPurpose.INVITED)
guest_list.add_guest_info(guest_info)
situation_manager.create_situation(situation, guest_list=guest_list, user_facing=False, zone_id=zone_id)
def unregister_custom_career(opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
sim_info.career_tracker.remove_custom_career_data()
return True
def set_statisitic(stat_type, value:float=None, opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is not None and stat_type is not None and value is not None:
tracker = target.get_tracker(stat_type)
tracker.set_value(stat_type, value)
else:
sims4.commands.output('No target for stats.set_stat.', _connection)
def add_career_performance(opt_sim: OptionalTargetParam = None,
amount: int = None,
career_type: TunableInstanceParam(
sims4.resources.Types.CAREER) = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('careers.add_performance Invalid Sim passed',
_connection)
sims4.commands.output(
'Usage: careers.add_performance <opt_sim> <amount>', _connection)
return
if amount is None:
sims4.commands.output('careers.add_performance Invalid amount passed',
_connection)
sims4.commands.output(
'Usage: careers.add_performance <opt_sim> <amount>', _connection)
return
if career_type is None:
sims4.commands.output('careers.add_performance Invalid career passed',
_connection)
if len(sim.sim_info.careers) > 0:
career = sim.sim_info.career_tracker.get_career_by_uid(
career_type.guid64)
if career is not None:
performance_stat = sim.statistic_tracker.get_statistic(
career.current_level_tuning.performance_stat)
performance_stat.add_value(amount)
def register_custom_career(opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
def on_response(dialog):
if not dialog.accepted:
return
name = dialog.text_input_responses.get(Career.TEXT_INPUT_NEW_NAME)
description = dialog.text_input_responses.get(
Career.TEXT_INPUT_NEW_DESCRIPTION)
sim_info.career_tracker.set_custom_career_data(
custom_name=name, custom_description=description)
register_dialog_data = Career.REGISTER_CAREER_DIALOG_DATA
dialog = register_dialog_data.register_career_dialog(
sim_info, SingleSimResolver(sim_info))
text_input_overrides = None
if sim_info.career_tracker.has_custom_career:
text_input_overrides = {}
custom_career_data = sim_info.career_tracker.custom_career_data
text_input_overrides[
Career.
TEXT_INPUT_NEW_NAME] = lambda *_, **__: LocalizationHelperTuning.get_raw_text(
custom_career_data.get_custom_career_name())
text_input_overrides[
Career.
TEXT_INPUT_NEW_DESCRIPTION] = lambda *_, **__: LocalizationHelperTuning.get_raw_text(
custom_career_data.get_custom_career_description())
dialog.show_dialog(on_response=on_response,
text_input_overrides=text_input_overrides)
return True
def reset_convergence(stat_type, opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is not None and stat_type is not None:
tracker = target.get_tracker(stat_type)
tracker.reset_convergence(stat_type)
else:
sims4.commands.output('No target for stats.reset_convergence.', _connection)
def automation_current_active_role(opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is None:
sims4.commands.automation_output('SimRole; SimId:None', _connection)
return False
role = target.active_roles().__class__.__name__ if target.active_roles() is not None else 'None'
sims4.commands.automation_output('SimRole; SimId:{}, Role:{}'.format(target.id, role), _connection)
def modify_gender_in_cas(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No valid target specified.', _connection)
return False
sims4.commands.client_cheat('sims.exit2caswithhouseholdid {} {} gender'.format(sim.id, sim.household_id), _connection)
return True
def show_statistics(display_skill_only=False, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
for stat in sim.statistics_gen():
while not display_skill_only or isinstance(stat, statistics.skill.Skill):
s = 'Statistic: {}, Value: {}, Level: {}.'.format(stat.__class__.__name__, stat.get_value(), stat.get_user_value())
sims4.commands.output(s, _connection)
def get_sims_for_job(session_id, sim_id, situation_type, job_type, *job_assignments, _connection=None):
sim = get_optional_target(sim_id, _connection)
situation_start_time = services.time_service().sim_now
duration = situation_type.duration
if duration > 0:
situation_end_time = situation_start_time + date_and_time.create_time_span(0, 0, duration)
else:
situation_start_time = date_and_time.INVALID_DATE_AND_TIME
situation_end_time = date_and_time.INVALID_DATE_AND_TIME
results = services.sim_filter_service().submit_filter(job_type.filter, None, requesting_sim_info=sim.sim_info, start_time=situation_start_time, end_time=situation_end_time, allow_yielding=False)
if job_type.additional_filter_for_user_selection:
sim_constraints = {result.sim_info.id for result in results}
results = services.sim_filter_service().submit_filter(job_type.additional_filter_for_user_selection, None, requesting_sim_info=sim.sim_info, start_time=situation_start_time, end_time=situation_end_time, sim_constraints=sim_constraints, allow_yielding=False)
msg = Situations_pb2.SituationJobSims()
msg.situation_session_id = session_id
msg.job_resource_id = job_type.guid
msg.requirements = job_type.requirement_text
results.sort(key=lambda x: (x.sim_info.is_npc, x.sim_info.last_name))
for result in results:
msg.sim_ids.append(result.sim_info.id)
with ProtocolBufferRollback(msg.sims) as situation_job_sim:
situation_job_sim.sim_id = result.sim_info.id
if result.sim_info.household.id == services.active_household_id():
situation_job_sim.account_id = result.sim_info.account_id
while result.conflicting_career_track_id:
situation_job_sim.career_track_id = result.conflicting_career_track_id
shared_messages.add_message_if_selectable(services.object_manager().get(sim.id), Consts_pb2.MSG_SITUATION_JOB_SIMS, msg, True)
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 mark_as_viewed(tuning_guid: int,
opt_target: OptionalSimInfoParam = None,
_connection=None):
target = get_optional_target(opt_target,
_connection,
target_type=OptionalSimInfoParam)
if target is None:
sims4.commands.output('No Sim with id {}'.format(opt_target),
_connection)
return False
unlock_tracker = target.unlock_tracker
if unlock_tracker is None:
sims4.commands.output(
'No unlock tracker for {}. Invalid LOD?'.format(target),
_connection)
return False
spells_manager = services.get_instance_manager(Types.SPELL)
recipe_manager = services.get_instance_manager(Types.RECIPE)
unlockable_class = spells_manager.get(tuning_guid) or recipe_manager.get(
tuning_guid)
if unlockable_class is None:
sims4.commands.output('Invalid guid {}'.format(tuning_guid),
_connection)
return False
unlock_tracker.unmark_as_new(unlockable_class)
def pregnancy_clear(sim_id: OptionalTargetParam = None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is not None:
pregnancy_tracker = sim.sim_info.pregnancy_tracker
pregnancy_tracker.clear_pregnancy()
return True
return False
def pregnancy_impregnate_many_npcs(opt_sim: OptionalSimInfoParam = None,
_connection=None):
output = sims4.commands.Output(_connection)
sim_info = get_optional_target(opt_sim,
_connection,
target_type=OptionalSimInfoParam)
if sim_info is None:
output('No valid SimInfo specified.')
return False
if sim_info.is_teen_or_younger:
output('Restricted to YAE Sims.')
return False
sim_info_manager = services.sim_info_manager()
for target_sim_info in sim_info_manager.get_all():
if sim_info.gender == target_sim_info.gender:
continue
if sim_info.species != target_sim_info.species:
continue
if target_sim_info.is_teen_or_younger:
continue
pregnancy_tracker = target_sim_info.pregnancy_tracker
if pregnancy_tracker is None:
continue
pregnancy_tracker.start_pregnancy(target_sim_info, sim_info)
output('\tImpregnated {}'.format(target_sim_info))
return True
def _csf_reset_slider(slider_name: str,
opt_sim: OptionalSimInfoParam = None,
_connection: int = None):
output = CheatOutput(_connection)
output('Resetting slider \'{}\'.'.format(slider_name))
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output('Failed, No Sim found!')
return False
output('Resetting slider for \'{}\'.'.format(
CommonSimNameUtils.get_full_name(sim_info)))
from cncustomsliderframework.sliders.query.slider_query_utils import CSFSliderQueryUtils
custom_sliders = CSFSliderQueryUtils().get_sliders_by_name(
sim_info, slider_name)
if not custom_sliders:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
custom_slider = next(iter(custom_sliders))
if custom_slider is not None:
output('Slider found.')
else:
output('Invalid Slider! \'{}\''.format(slider_name))
output('Available Sliders:')
for custom_slider in CSFSliderQueryUtils().get_sliders_for_sim(
sim_info):
output('>{}'.format(custom_slider.raw_display_name))
return False
CSFCustomSliderApplicationService().reset_slider(sim_info, custom_slider)
output('Success, Sliders reset.')
def list_favorites(opt_sim: OptionalSimInfoParam = None, _connection=None):
output = sims4.commands.Output(_connection)
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
output("Can't find provided Sim.")
return
favorites_tracker = sim_info.favorites_tracker
if favorites_tracker is None:
output('Sim has no favorites tracker.')
return
favorites = favorites_tracker.favorites
if not favorites:
output('Sim has no favorites objects.')
return
zone = services.current_zone()
for (tag, obj_id) in favorites.items():
output_str = str(tag) + '\t'
obj_inst = zone.find_object(obj_id)
if obj_inst is None:
output_str += 'None (error?)'
else:
output_str += str(obj_inst)
output(output_str)
def remove_static_commodity_from_tracker(static_commodity, opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is not None:
tracker = target.get_tracker(static_commodity)
tracker.remove_statistic(static_commodity)
else:
sims4.commands.output('No target for stats.remove_static_commodity_from_tracker. Params: stat_name, optional target', _connection)
def make_greeted(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Invalid sim: {} provided.'.format(opt_sim), _connection)
return
situation_manager = services.get_zone_situation_manager()
situation_manager.make_waiting_player_greeted(sim)
def show_commodities(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
sim.commodity_tracker.debug_output_all(_connection)
sim.statistic_tracker.debug_output_all(_connection)
else:
sims4.commands.output('No target for stats.show_commodities.', _connection)
def complete_current_milestone(opt_sim: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
track_id = sim.sim_info.primary_aspiration.guid64 if sim.sim_info.primary_aspiration is not None else 0
if track_id == 0:
sims4.commands.output(
"{} doesn't have a primary aspiration.".format(sim),
_connection)
return
track = get_tunable_instance(sims4.resources.Types.ASPIRATION_TRACK,
track_id)
for (_, track_aspriation) in track.get_aspirations():
if not sim.sim_info.aspiration_tracker.milestone_completed(
track_aspriation):
for objective_type in track_aspriation.objectives:
if not sim.sim_info.aspiration_tracker.objective_completed(
objective_type):
sim.sim_info.aspiration_tracker.complete_objective(
objective_type)
sim.sim_info.aspiration_tracker.complete_milestone(
track_aspriation, sim.sim_info)
sims4.commands.output(
'Complete {} on {}'.format(track_aspriation, sim),
_connection)
sim.sim_info.aspiration_tracker.send_if_dirty()
return
sims4.commands.output(
'{} has completed all milestones in {}.'.format(sim, track),
_connection)
def order_food(recipe_type: TunableInstanceParam(sims4.resources.Types.RECIPE),
opt_sim: OptionalTargetParam = None,
_connection=None):
if recipe_type is None:
sims4.commands.output('Recipe is None', _connection)
sims4.commands.automation_output('RestaurantOrderFood; Status:Failed',
_connection)
return False
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output("Sim {} doesn't exist".format(opt_sim),
_connection)
sims4.commands.automation_output('RestaurantOrderFood; Status:Failed',
_connection)
return False
zone_director = get_restaurant_zone_director()
if zone_director is None:
sims4.commands.output('Current venue is not restaurant', _connection)
sims4.commands.automation_output('RestaurantOrderFood; Status:Failed',
_connection)
return False
zone_director.make_one_order(sim, recipe_type)
groups = zone_director.get_dining_groups_by_sim(sim)
if groups is None:
sims4.commands.output('Sim {} is not in dining group'.format(opt_sim),
_connection)
sims4.commands.automation_output('RestaurantOrderFood; Status:Failed',
_connection)
group = groups.pop()
group.hold_ordered_cost(recipe_type.restaurant_base_price)
sims4.commands.automation_output('RestaurantOrderFood; Status:Success',
_connection)
return True
def npc_accept_or_reject_recommendation(opt_sim: OptionalTargetParam = None,
accept_recommendation: bool = True,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output("Sim {} doesn't exist.".format(opt_sim),
_connection)
return False
zone_director = get_restaurant_zone_director()
if zone_director is None:
sims4.commands.output('Current venue is not restaurant', _connection)
return False
group_order = zone_director.get_active_group_order_for_sim(sim.sim_id)
if group_order is None:
sims4.commands.output(
'Sim {} was not offered a recommendation.'.format(opt_sim),
_connection)
return False
if accept_recommendation:
sim_order = group_order.get_sim_order(sim.sim_id)
if sim_order is not None:
sim_order.recommendation_state = OrderRecommendationState.RECOMMENDATION_ACCEPTED
else:
group_order.remove_sim_order(sim.sim_id)
(food_recipe, drink_recipe) = ChefsChoice.get_order_for_npc_sim(sim)
group_order.add_sim_order(
sim.sim_id,
food_recipe_id=food_recipe.guid64,
drink_recipe_id=drink_recipe.guid64,
recommendation_state=OrderRecommendationState.
RECOMMENDATION_REJECTED,
order_status=OrderStatus.ORDER_INIT)
return True
def genalogy_print(sim_id:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is None:
return False
genealogy = sim.sim_info.genealogy
genealogy.log_contents()
return True
def modify_in_cas(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No valid target for sims.modify_in_cas.', _connection)
return False
sims4.commands.client_cheat('sims.exit2cas {} {} {}'.format(sim.id, sim.household_id, services.get_active_sim().id), _connection)
return True
def reset_aspirations(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
sim.sim_info.aspiration_tracker.reset_data()
sims4.commands.output('Aspirations reset complete', _connection)
else:
sims4.commands.output('Sim not found, please check: |aspirations.reset_data <sim id from desired account>', _connection)
def clear_lockouts(opt_sim: OptionalTargetParam = None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
sim.clear_all_lockouts()
else:
sims4.commands.output('No target for objects.clear_lockouts.',
_connection)
def clear_relationships(source_sim_id: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(source_sim_id, _connection)
if sim is not None:
source_sim_info = sim.sim_info
else:
if not source_sim_id:
sims4.commands.output(
'No sim_info id specified for relationship.clear', _connection)
return False
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
sims4.commands.output('Invalid sim_info id: {}'.format(source_sim_id),
_connection)
return False
tracker = source_sim_info.relationship_tracker
if tracker:
rel_list = list(tracker)
for relationship in rel_list:
tracker.destroy_relationship(
relationship.get_other_sim_id(source_sim_id))
sims4.commands.output(
'Removed {} relationships from {}'.format(len(rel_list), sim),
_connection)
else:
logger.error("Sim {} doesn't have a RelationshipTracker",
source_sim_info)
return True
def genalogy_print(sim_id: OptionalTargetParam = None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is None:
return False
genealogy = sim.sim_info.genealogy
genealogy.log_contents()
return True
def pregnancy_clear(sim_id:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is not None:
pregnancy_tracker = sim.sim_info.pregnancy_tracker
pregnancy_tracker.clear_pregnancy()
return True
return False
def get_carried_objects(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Invalid Sim id: {}'.format(opt_sim), _connection)
return False
for (hand, _, obj) in get_carried_objects_gen(sim):
sims4.commands.output('\t{}: {}'.format(hand, obj), _connection)
return True
def current_active_role(opt_target:OptionalTargetParam=None, _connection=None):
target = get_optional_target(opt_target, _connection)
if target is None:
return False
if target.active_roles():
sims4.commands.output('Active Roles: {}'.format(target.active_roles()), _connection)
else:
sims4.commands.output('Sim has no active role', _connection)
def start_single_sim_performance_test(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No target for qa.automation.start_single_sim_performance_test', _connection)
return
sim.reset(ResetReason.RESET_EXPECTED, None, 'start_single_sim_performance_test')
services.autonomy_service().start_single_sim_load_test(_connection, sim)
sim.run_full_autonomy_next_ping()
def pregnancy_seed(seed, sim_id:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is not None:
pregnancy_tracker = sim.sim_info.pregnancy_tracker
if pregnancy_tracker.is_pregnant:
pregnancy_tracker._seed = seed
return True
return False
def reset_achievements(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
account = services.account_service().get_account_by_id(sim.sim_info.account_id)
account.achievement_tracker.reset_data()
sims4.commands.output('Achievements reset complete', _connection)
else:
sims4.commands.output('Account not found, please check: |achievements.reset_data <sim id from desired account>', _connection)
def career_demote_sim(career_type, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
career = sim.sim_info.career_tracker.get_career_by_uid(career_type.guid64)
if career is not None:
career.demote()
return True
return False
def remove_modifier(handle, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No target for autonomy.add_modifier', _connection)
return
if sim.remove_statistic_modifier(handle):
sims4.commands.output('Successfully removed autonomy modifier', _connection)
else:
sims4.commands.output('Unable to find autonomy handle: {}'.format(handle), _connection)
def create_situation(situation_type, opt_sim:OptionalTargetParam=None, user_facing:bool=True, zone_id:int=0, _connection=None):
situation_manager = services.get_zone_situation_manager()
sim = get_optional_target(opt_sim, _connection)
guest_list = SituationGuestList(False, sim.id)
situation_id = situation_manager.create_situation(situation_type, guest_list=guest_list, user_facing=user_facing, zone_id=zone_id)
if situation_id is not None:
sims4.commands.output('Successfully created situation: {}.'.format(situation_id), _connection)
else:
sims4.commands.output('Insufficient funds to create situation', _connection)
def dump_test_based_score_info(test_set, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
return False
si = max(sim.si_state, key=lambda si: (si.is_social, si.priority, si.id))
output = sims4.commands.Output(_connection)
output('Generating test scores for {} using resolver {}'.format(sim, si))
test_set.debug_dump(si.get_resolver(), dump=output)
return True
def filter_create_friends(number_to_create, opt_sim:OptionalTargetParam=None, _connection=None):
def callback(sim_infos, callback_event_data):
if sim_infos:
for sim_info in sim_infos:
sims4.commands.output('Created info name {}'.format(sim_info.full_name), _connection)
sim = get_optional_target(opt_sim, _connection)
services.sim_filter_service().submit_matching_filter(number_to_create, filters.tunable.TunableSimFilter.ANY_FILTER, callback, requesting_sim_info=sim.sim_info, continue_if_constraints_fail=True, allow_yielding=True, blacklist_sim_ids={sim_info.id for sim_info in services.sim_info_manager().values()})
def singe_sim(opt_target:OptionalTargetParam=None, set_singed:bool=None, _connection=None):
sim = get_optional_target(opt_target, _connection)
if sim is None:
return False
sim_info = sim.sim_info
if set_singed is None:
sim_info.singed = not sim_info.singed
else:
sim_info.singed = set_singed
def show_autonomy_settings(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output("Couldn't find Sim.", _connection)
return
autonomy_state = _convert_state_to_string(sim.get_autonomy_state_setting())
autonomy_randomization = _convert_randomization_to_string(sim.get_autonomy_randomization_setting())
selected_sim_autonomy_enabled = services.autonomy_service()._selected_sim_autonomy_enabled
sims4.commands.output('Autonomy State: {}\nAutonomyRandomization: {}\nSelected Sim Autonomy: {}'.format(autonomy_state, autonomy_randomization, selected_sim_autonomy_enabled), _connection)
def trigger_invite_over_phone_call(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No sim for households.debug_trigger_invite_over_phone_call.', _connection)
return False
if not services.household_manager().debug_trigger_invite_over_phone_call(sim):
sims4.commands.output('households.debug_trigger_invite_over_phone_call failed to trigger phone call.', _connection)
return False
return True
def genealogy_prune(sim_id:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(sim_id, _connection)
if sim is None:
return False
household = sim.household
if household is None:
return False
household.prune_distant_relatives()
return True
def get_prepopulated_job_for_sims(session_id, situation_type, sim_id:OptionalTargetParam=None, opt_target_id:int=None, _connection=None):
sim = get_optional_target(sim_id, _connection)
prepopulate = situation_type.get_prepopulated_job_for_sims(sim, opt_target_id)
assign_msg = Situations_pb2.SituationAssignJob()
assign_msg.situation_session_id = session_id
if prepopulate is not None:
for (sim_id, job_type_id) in prepopulate:
assign_msg.sim_ids.append(sim_id)
assign_msg.job_resource_ids.append(job_type_id)
shared_messages.add_object_message(sim, Consts_pb2.MSG_SITUATION_ASSIGN_JOB, assign_msg, True)
def test_situation_available(situation_type, opt_sim:OptionalTargetParam=None, target_sim_id:int=0, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Invalid sim: {} provided.'.format(opt_sim), _connection)
return
situation_name = str(situation_type)
if situation_type.is_situation_available(sim, target_sim_id):
sims4.commands.output('Situation {} with initiating sim {} and target sim {} is available.'.format(situation_name, sim, target_sim_id), _connection)
else:
sims4.commands.output('Situation {} with initiating sim {} and target sim {} is not available.'.format(situation_name, sim, target_sim_id), _connection)
def introduce_sim_to_all_others(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No valid target for relationship.introduce_sim_to_all_others', _connection)
return
for target_sim in services.sim_info_manager().objects:
if target_sim.id == sim.id:
pass
sim.relationship_tracker.add_relationship_score(target_sim.sim_id, RelationshipCommandTuning.INTRODUCE_VALUE, RelationshipCommandTuning.INTRODUCE_TRACK)
target_sim.relationship_tracker.add_relationship_score(sim.sim_id, RelationshipCommandTuning.INTRODUCE_VALUE, RelationshipCommandTuning.INTRODUCE_TRACK)
def remove_all_topic_of_type(name:str=None, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None or name is None:
return False
topic_type = services.topic_manager().get(name)
if topic_type is None:
sims4.commands.output('({0}) is not a valid topic'.format(name), _connection)
return False
sim.remove_all_topic_of_type(topic_type)
return True
def complete_achievement(achievement_type, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
if achievement_type is not None:
account = services.account_service().get_account_by_id(sim.sim_info.account_id)
account.achievement_tracker.reset_milestone(achievement_type.guid64)
account.achievement_tracker.complete_milestone(achievement_type, sim.sim_info)
sims4.commands.output('Complete {} on {}'.format(achievement_type, sim), _connection)
account.achievement_tracker.send_if_dirty()
else:
sims4.commands.output('Achievement {} not found, please check: |achievements.list_all_achievements'.format(achievement_type, sim), _connection)
def household_autonomy_randomization(randonmization, opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Failed to find Sim', _connection)
return
household = sim.household
if household is None:
sims4.commands.output('No household for sim {}'.format(sim), _connection)
return
true_randomization = _parse_randomization(randonmization)
household.autonomy_settings.set_randomization_setting(true_randomization)
def give_royalties(opt_sim:OptionalTargetParam=None, _connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('Target Sim could not be found.', _connection)
return False
royalty_tracker = sim.sim_info.royalty_tracker
if royalty_tracker is None:
sims4.commands.output('Royalty Tracker not found for Sim.', _connection)
return False
royalty_tracker.update_royalties_and_get_paid()
return True
def filter_invite(filter_type, opt_sim:OptionalTargetParam=None, _connection=None):
def _spawn_found_sims(results, callback_event_data):
if results is not None:
for result in results:
sims4.commands.output('Sim : {}'.format(result.sim_info.id), _connection)
sims.sim_spawner.SimSpawner.load_sim(result.sim_info.id)
logger.info('Sims ID matching request {0}', results)
sim = get_optional_target(opt_sim, _connection)
_find_sims_with_filter(filter_type, sim, _spawn_found_sims, _connection)
