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 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 complete_course(course: TunableInstanceParam(
sims4.resources.Types.UNIVERSITY_COURSE_DATA),
course_score: int = 100,
opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
sims4.commands.output('No valid target for university.complete_course',
_connection)
return False
degree_tracker = sim_info.degree_tracker
if degree_tracker is None:
sims4.commands.output(
'Sim: {} has no degree tracker in university.complete_course'.
format(sim_info), _connection)
return False
for (course_guid,
course_info) in list(degree_tracker._course_infos.items()):
if course_info.course_data is course:
course_info.lectures = degree_tracker.COURSE_LECTURE_COUNT
course_info.final_requirement_completed = True
degree_tracker.course_infos[course_guid] = course_info
degree_tracker.complete_course(course_guid, course_score)
return True
sims4.commands.output(
'Sim is not currently enrolled in course {}'.format(course),
_connection)
return False
def enable_woohoo(source_sim_id: int, target_sim_id: int, _connection=None):
output = sims4.commands.Output(_connection)
(source_sim_info,
target_sim_info) = _get_source_and_target(source_sim_id, target_sim_id,
output)
if source_sim_info is None or target_sim_info is None:
return False
if source_sim_info.age <= sims.sim_info_types.Age.TEEN:
output('Source sim is underage.')
return False
if target_sim_info.age <= sims.sim_info_types.Age.TEEN:
output('Target sim is underage.')
return False
for bit in CheatWoohooTuning.CHEAT_WOOHOO_BITS:
source_sim_info.relationship_tracker.add_relationship_bit(
target_sim_id, bit)
source_sim_info.relationship_tracker.add_relationship_score(
target_sim_id, 100, CheatWoohooTuning.CHEAT_WOOHOO_TRACK)
source_sim_info.relationship_tracker.add_relationship_score(
target_sim_id, 100, CheatWoohooTuning.CHEAT_WOOHOO_SOCIALCONTEXT)
tracker = source_sim_info.get_tracker(
CheatWoohooTuning.CHEAT_WOOHOO_COMMODITY)
tracker.set_value(CheatWoohooTuning.CHEAT_WOOHOO_COMMODITY, 100)
tracker = target_sim_info.get_tracker(
CheatWoohooTuning.CHEAT_WOOHOO_COMMODITY)
tracker.set_value(CheatWoohooTuning.CHEAT_WOOHOO_COMMODITY, 100)
source_sim_info.debug_add_buff_by_type(CheatWoohooTuning.CHEAT_WOOHOO_BUFF)
target_sim_info.debug_add_buff_by_type(CheatWoohooTuning.CHEAT_WOOHOO_BUFF)
buff = TunableInstanceParam(sims4.resources.Types.BUFF)(12482)
for sim in (source_sim_info, target_sim_info):
if sim.has_buff(buff):
sim.remove_buff_by_type(buff)
def create_pet_with_breed(breed: TunableInstanceParam(
sims4.resources.Types.BREED),
gender: Gender = Gender.FEMALE,
age: Age = Age.ADULT,
x: float = 0,
y: float = 0,
z: float = 0,
_connection=None):
if age not in (Age.CHILD, Age.ADULT, Age.ELDER):
sims4.commands.output('Invalid age for pet: {}'.format(age),
_connection)
return
client = services.client_manager().get(_connection)
position = sims4.math.Vector3(x, y, z) if x and y and z else None
sims4.commands.output('Creating pet with breed: {}'.format(breed.__name__),
_connection)
sim_creator = SimCreator(age=age,
gender=gender,
species=breed.breed_species,
additional_tags=(breed.breed_tag, ))
SimSpawner.create_sims((sim_creator, ),
household=None,
tgt_client=client,
generate_deterministic_sim=True,
sim_position=position,
account=client.account,
creation_source='cheat: pets.create_pet_with_breed')
def load_conditional_layer(conditional_layer:TunableInstanceParam(sims4.resources.Types.CONDITIONAL_LAYER), immediate:bool=True, timer_interval:int=1, timer_object_count:int=5):
if conditional_layer is None:
sims4.commands.output('Unable to find the conditional_layer instance specified.')
return
conditional_layer_service = services.conditional_layer_service()
speed = ConditionalLayerRequestSpeedType.IMMEDIATELY if immediate else ConditionalLayerRequestSpeedType.GRADUALLY
conditional_layer_service.load_conditional_layer(conditional_layer, speed=speed, timer_interval=timer_interval, timer_object_count=timer_object_count)
def add_zone_modifier(zone_modifier: TunableInstanceParam(
sims4.resources.Types.ZONE_MODIFIER),
target_zone_id: int = None,
_connection=None):
if target_zone_id is None:
target_zone_id = services.current_zone_id()
persistence_service = services.get_persistence_service()
zone_data = persistence_service.get_zone_proto_buff(
services.current_zone_id())
if zone_data is None:
return
if len(zone_data.lot_traits) == ZONE_MODIFIER_CAP:
sims4.commands.output(
'There are already {} lot traits on the lot. Remove one first.'.
format(ZONE_MODIFIER_CAP), _connection)
return
zone_modifier_id = zone_modifier.guid64
if zone_modifier_id in zone_data.lot_traits:
sims4.commands.output(
'{} is already a trait on the lot.'.format(zone_modifier),
_connection)
return
zone_data.lot_traits.append(zone_modifier_id)
services.get_zone_modifier_service(
).check_for_and_apply_new_zone_modifiers(target_zone_id)
def ranked_stat_get_rank(
opt_sim: OptionalSimInfoParam = None,
stat_type: TunableInstanceParam(sims4.resources.Types.STATISTIC,
exact_match=True) = None,
_connection=None):
sim = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim is None:
sims4.commands.output('No Sim specified, you must specify a Sim.',
_connection)
sims4.commands.automation_output('RankedStat; Status:Failed',
_connection)
return
if not hasattr(stat_type, 'rank_level'):
sims4.commands.output(
'The specified statistic is not a Ranked Statistic and therefore has no Rank, please specify a Ranked Statistic.',
_connection)
sims4.commands.automation_output('RankedStat; Status:Failed',
_connection)
return
commodity_tracker = sim.commodity_tracker
stat = commodity_tracker.get_statistic(stat_type)
sims4.commands.automation_output(
'RankedStat; Status:Success, RankLevel:{}'.format(stat.rank_level),
_connection)
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 ranked_stat_set_rank(
opt_sim: OptionalSimInfoParam = None,
stat_type: TunableInstanceParam(sims4.resources.Types.STATISTIC,
exact_match=True) = None,
rank: int = 1,
_connection=None):
sim = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim is None:
sims4.commands.output(
'No Sim specified, you must specify a Sim to set the rank on.',
_connection)
return
if not hasattr(stat_type, 'rank_level'):
sims4.commands.output(
'The specified statistic is not a Ranked Statistic and therefore has no Rank, please specify a Ranked Statistic.',
_connection)
return
commodity_tracker = sim.commodity_tracker
stat = commodity_tracker.get_statistic(stat_type)
if stat.rank_level == rank:
return
stat.set_value(stat.points_to_rank(rank))
if stat.rank_level == rank:
sims4.commands.output('Success.', _connection)
else:
sims4.commands.output(
'Failure, sim is now set to rank {}'.format(stat.rank_level),
_connection)
def publish_ranked_stat_progress(opt_sim: OptionalSimInfoParam = None,
stat_type: TunableInstanceParam(
sims4.resources.Types.STATISTIC,
exact_match=True) = None,
_connection=None):
sim = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim is None:
sims4.commands.output(
'No Sim specified, you must specify a Sim to get the rank.',
_connection)
return
if not hasattr(stat_type, 'rank_level'):
sims4.commands.output(
'The specified statistic is not a Ranked Statistic and therefore has no Rank, please specify a Ranked Statistic.',
_connection)
return
commodity_tracker = sim.commodity_tracker
stat = commodity_tracker.get_statistic(stat_type)
if stat is None:
sims4.commands.output("Sim doesn't have the specified statistic.",
_connection)
return
stat.create_and_send_commodity_update_msg(is_rate_change=False,
allow_npc=True)
def add_open_street_director(open_street_director_type: TunableInstanceParam(
sims4.resources.Types.OPEN_STREET_DIRECTOR),
_connection=None):
zone_director = services.venue_service().get_zone_director()
zone_director.set_open_street_director(open_street_director_type())
sims4.commands.output(
'Open Street Director changed to {}.'.format(
zone_director.open_street_director), _connection)
def activate_timed_aspiration(aspiration_type: TunableInstanceParam(
sims4.resources.Types.ASPIRATION),
opt_sim: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
return
sim.sim_info.aspiration_tracker.activate_timed_aspiration(aspiration_type)
def remove_career_from_sim(career_type: TunableInstanceParam(
sims4.resources.Types.CAREER),
opt_sim: OptionalTargetParam = None,
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is not None:
sim.sim_info.career_tracker.remove_career(career_type.guid64)
return True
return False
def give_reward(
reward_type: TunableInstanceParam(sims4.resources.Types.REWARD),
opt_sim: server_commands.argument_helpers.OptionalTargetParam = None,
_connection=None):
output = sims4.commands.Output(_connection)
sim = server_commands.argument_helpers.get_optional_target(
opt_sim, _connection)
reward_type.give_reward(sim.sim_info)
output('Successfully gave the reward.')
def disable_commodities(opt_sim: OptionalTargetParam = None,
*stat_types: TunableInstanceParam(
sims4.resources.Types.STATISTIC, exact_match=True),
_connection=None):
sim = get_optional_target(opt_sim, _connection)
if sim is None:
sims4.commands.output('No valid target for stats.disable_commodities',
_connection)
return
_disable_commodities(sim, stat_types)
def set_primary_track(aspiration_track: TunableInstanceParam(
sims4.resources.Types.ASPIRATION_TRACK),
sim_id: int = 0,
_connection=None):
sim_info = services.sim_info_manager().get(sim_id)
if sim_info is None:
logger.error('Sim Info not found')
return False
sim_info.primary_aspiration = aspiration_track
return True
def fill_motive(
stat_type: TunableInstanceParam(sims4.resources.Types.STATISTIC,
exact_match=True),
_connection=None):
if stat_type is not None:
tgt_client = services.client_manager().get(_connection)
tracker = tgt_client.active_sim.get_tracker(stat_type)
tracker.set_value(stat_type, stat_type.max_value)
return True
return False
def venue_civic_policy_vote(
policy: TunableInstanceParam(sims4.resources.Types.SNIPPET),
count: int = 1,
_connection=None):
source_venue = services.venue_service().source_venue
if source_venue is None or not (
source_venue.civic_policy_provider is None
or not source_venue.civic_policy_provider.vote(policy, count)):
sims4.commands.cheat_output('Could not add vote to {}'.format(policy),
_connection)
def career_retire_sim(
career_type: TunableInstanceParam(sims4.resources.Types.CAREER),
opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
return False
sim_info.career_tracker.retire_career(career_type.guid64)
return True
def qa_object_def_valid_inventory_types(object_definition:TunableInstanceParam(sims4.resources.Types.OBJECT), _connection=None):
sims4.commands.automation_output('QaObjDefValidInventoryTypes; Status:Begin', _connection)
if object_definition is None:
sims4.commands.automation_output('QaObjDefValidInventoryTypes; Status:End')
return False
if object_definition.cls._components.inventory_item is not None:
valid_inventory_types = object_definition.cls._components.inventory_item._tuned_values.valid_inventory_types
if valid_inventory_types is not None:
for inventory_type in valid_inventory_types:
sims4.commands.automation_output('QaObjDefValidInventoryTypes; Status:Data, InventoryType:{}'.format(inventory_type), _connection)
sims4.commands.automation_output('QaObjDefValidInventoryTypes; Status:End', _connection)
def broadcasters_add(broadcaster_type: TunableInstanceParam(
sims4.resources.Types.BROADCASTER),
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)
broadcaster_service = broadcaster.get_broadcaster_service()
broadcaster_service.add_broadcaster(broadcaster)
return True
def reset_convergence(stat_type: TunableInstanceParam(
sims4.resources.Types.STATISTIC, exact_match=True),
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 venue_civic_policy_repeal(
policy: TunableInstanceParam(sims4.resources.Types.SNIPPET),
_connection=None):
source_venue = services.venue_service().source_venue
if source_venue is None or not (
source_venue.civic_policy_provider is None
or not source_venue.civic_policy_provider.repeal(policy)):
sims4.commands.automation_output('{} not repealed'.format(policy),
_connection)
sims4.commands.cheat_output('{} not repealed'.format(policy),
_connection)
def remove_bit(source_sim_id: int,
target_sim_id: int,
rel_bit: TunableInstanceParam(
sims4.resources.Types.RELATIONSHIP_BIT),
_connection=None):
source_sim_info = services.sim_info_manager().get(source_sim_id)
if source_sim_info is None:
return False
source_sim_info.relationship_tracker.remove_relationship_bit(
target_sim_id, rel_bit)
return True
def modify_relationship(info1: SimInfoParam,
info2: SimInfoParam,
amount: float = 0,
track_type: TunableInstanceParam(
sims4.resources.Types.STATISTIC) = None,
_connection=None):
if info1 is not None and info2 is not None:
info1.relationship_tracker.add_relationship_score(
info2.id, amount, track_type)
return True
return False
def ui_trigger_screenslam(screenslam_reference: TunableInstanceParam(
sims4.resources.Types.SNIPPET),
opt_sim: OptionalSimInfoParam = None,
_connection=None):
sim_info = get_optional_target(opt_sim,
target_type=OptionalSimInfoParam,
_connection=_connection)
if sim_info is None:
return False
screenslam_reference.send_screen_slam_message(sim_info)
return True
def career_demote_sim(
career_type: TunableInstanceParam(sims4.resources.Types.CAREER),
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 unlock_spell(spell_type: TunableInstanceParam(sims4.resources.Types.SPELL),
opt_target: OptionalSimInfoParam = None,
_connection=None):
target = get_optional_target(opt_target,
_connection,
target_type=OptionalSimInfoParam)
if target is None:
return False
unlock_tracker = target.unlock_tracker
if unlock_tracker is None:
return False
unlock_tracker.add_unlock(spell_type, None, mark_as_new=True)
def dump_test_based_score_info(test_set: TunableInstanceParam(
sims4.resources.Types.TEST_BASED_SCORE),
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
