def _get_sex_handler_animation_duration(animation_instance, is_npc_only=False):
if is_npc_only is True:
animation_single_loop_duration = animation_instance.get_single_loop_duration(
)
progression_duration = get_sex_setting(
SexSetting.NPC_SEX_DURATION_VALUE, variable_type=int) * 60 / 12
if progression_duration >= int(animation_instance.get_duration()):
animation_duration = int(
animation_instance.get_duration_milliseconds()) - 4
else:
animation_duration = int(
max(int(progression_duration / animation_single_loop_duration),
1) * animation_single_loop_duration * 1000) - 4
elif get_sex_setting(
SexSetting.SEX_ANIMATION_DURATION_OVERRIDE_TYPE,
variable_type=int) == SexAnimationDurationOverrideType.OVERRIDE:
animation_single_loop_duration = animation_instance.get_single_loop_duration(
)
animation_duration = int(
max(
1,
int(
get_sex_setting(
SexSetting.SEX_ANIMATION_DURATION_OVERRIDE_VALUE,
variable_type=int) / animation_single_loop_duration)) *
animation_single_loop_duration * 1000)
else:
animation_duration = int(
animation_instance.get_duration_milliseconds())
return animation_duration
def get_gender_type(self, default_gender=False):
if default_gender is True:
return self.gender_type
if get_sex_setting(
SexSetting.SEX_GENDER_TYPE,
variable_type=int) == SexGenderTypeSetting.ANY_BASED:
if self.gender_type == SexGenderType.CMALE or self.gender_type == SexGenderType.CFEMALE or self.gender_type == SexGenderType.CBOTH:
return SexGenderType.CBOTH
return SexGenderType.BOTH
if self.gender_type == SexGenderType.CFEMALE and get_sex_setting(
SexSetting.GENDER_RECOGNITION_FEMALE_TO_BOTH_STATE,
variable_type=bool):
return SexGenderType.CBOTH
if self.gender_type == SexGenderType.CMALE and get_sex_setting(
SexSetting.GENDER_RECOGNITION_MALE_TO_BOTH_STATE,
variable_type=bool):
return SexGenderType.CBOTH
if self.gender_type == SexGenderType.FEMALE and get_sex_setting(
SexSetting.GENDER_RECOGNITION_FEMALE_TO_BOTH_STATE,
variable_type=bool):
return SexGenderType.BOTH
if self.gender_type == SexGenderType.MALE and get_sex_setting(
SexSetting.GENDER_RECOGNITION_MALE_TO_BOTH_STATE,
variable_type=bool):
return SexGenderType.BOTH
return self.gender_type
def _is_sim_on_birth_control(sim_identifier):
if get_sex_setting(SexSetting.BIRTH_CONTROL_MODE,
variable_type=int) == BirthControlModeSetting.PERFECT:
if has_sim_trait(sim_identifier,
SimTrait.GENDEROPTIONS_PREGNANCY_CANIMPREGNATE
) and sim_ev(sim_identifier).has_condom_on is True:
return True
if has_sim_trait(
sim_identifier,
SimTrait.GENDEROPTIONS_PREGNANCY_CANBEIMPREGNATED
) and sim_ev(
sim_identifier
).day_used_birth_control_pills == TurboWorldUtil.Time.get_absolute_days(
):
return True
return False
if get_sex_setting(SexSetting.BIRTH_CONTROL_MODE,
variable_type=int) == BirthControlModeSetting.REALISTIC:
random_inst = random.Random(
(TurboWorldUtil.Time.get_absolute_days() +
TurboWorldUtil.Time.get_absolute_hours()) * 768)
if has_sim_trait(sim_identifier,
SimTrait.GENDEROPTIONS_PREGNANCY_CANIMPREGNATE
) and sim_ev(sim_identifier).has_condom_on is True:
return random_inst.uniform(0, 1) < 0.95
if has_sim_trait(
sim_identifier,
SimTrait.GENDEROPTIONS_PREGNANCY_CANBEIMPREGNATED
) and sim_ev(
sim_identifier
).day_used_birth_control_pills == TurboWorldUtil.Time.get_absolute_days(
):
return random_inst.uniform(0, 1) < 0.91
return False
return False
def _after_sex_cum(sex_handler, actor_id, sim_info):
if sex_handler.get_animation_instance() is None or not get_sex_setting(
SexSetting.CUM_VISIBILITY_STATE, variable_type=bool):
return
cum_layers = sex_handler.get_animation_instance(
).get_actor_received_cum_layers(actor_id)
if not cum_layers:
actions = sex_handler.get_animation_instance(
).get_actor_received_actions(actor_id)
for (action_actor_id, action_type, is_cum_inside) in actions:
if is_cum_inside is True:
pass
cum_layer_type = get_cum_layer_from_sex_category(action_type)
while cum_layer_type is not CumLayerType.NONE:
cum_layers.append((action_actor_id, (cum_layer_type, )))
for (action_actor_id, cum_layer_types) in cum_layers:
action_actor_sim_id = sex_handler.get_sim_id_by_actor_id(
action_actor_id)
if action_actor_sim_id is None:
pass
action_actor_sim_info = TurboManagerUtil.Sim.get_sim_info(
action_actor_sim_id)
if not has_sim_trait(action_actor_sim_info,
SimTrait.GENDEROPTIONS_TOILET_STANDING):
pass
if not get_sex_setting(
SexSetting.CUM_VISIBILITY_WITH_CONDOM_STATE, variable_type=bool
) and sim_ev(action_actor_sim_info).has_condom_on is True:
pass
apply_sim_cum_layer(sim_info, cum_layer_types)
def try_progress_sex_interaction(sex_handler, is_manual=False):
if sex_handler.is_npc_only():
if sex_handler.get_animation_instance().get_sex_category(
) == SexCategoryType.CLIMAX:
return
animation_duration = _get_sex_handler_animation_duration(
sex_handler.get_animation_instance(), is_npc_only=True)
else:
if get_sex_setting(
SexSetting.SEX_PROGRESSION_TYPE, variable_type=int
) == SexProgressionLevelSetting.DISABLED and is_manual is False:
return
if sex_handler.get_animation_instance().get_sex_category(
) == SexCategoryType.CLIMAX and not get_sex_setting(
SexSetting.CLIMAX_SEX_PROGRESSION_STATE, variable_type=bool):
return
animation_duration = _get_sex_handler_animation_duration(
sex_handler.get_animation_instance())
if is_manual is True or sex_handler.animation_counter >= animation_duration:
sex_handler.animation_counter = 0
if sex_handler.next_animation_instance is not None and sex_handler.next_animation_instance != sex_handler.get_animation_instance(
):
if is_sim_allowed_for_animation(
sex_handler.get_actors_sim_info_gen(),
sex_handler.next_animation_instance.get_sex_category()):
sex_handler.set_animation_instance(
sex_handler.next_animation_instance,
is_animation_change=True)
sex_handler.next_animation_instance = None
sex_handler.play(is_animation_change=True)
def get_chance_for_random_sex_autonomy(sims_list,
skip_hypersexual_lot_check=False):
if skip_hypersexual_lot_check and False and is_sims_list_at_hypersexual_lot(
sims_list):
return 1.0
self_assured_multiplier = [
has_sim_trait(sim_info, SimTrait.SELFASSURED) for sim_info in sims_list
].count(True)
is_at_night = TurboWorldUtil.Time.get_hour_of_day(
) <= 5 or TurboWorldUtil.Time.get_hour_of_day() >= 23
is_at_weekend = TurboWorldUtil.Time.get_day_of_week() >= 5
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.HIGH:
return SEX_AUTONOMY_HIGH_LEVEL_BASE_CHANCE + (
0.017 if is_at_weekend else 0.0
) + (
0.005 if is_at_night else 0.0
) + 0.003 * self_assured_multiplier + get_sex_autonomy_failure_chance(
)
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.NORMAL:
return SEX_AUTONOMY_NORMAL_LEVEL_BASE_CHANCE + (
0.015 if is_at_weekend else 0.0
) + (
0.003 if is_at_night else 0.0
) + 0.002 * self_assured_multiplier + get_sex_autonomy_failure_chance(
)
return SEX_AUTONOMY_LOW_LEVEL_BASE_CHANCE + (
0.015 if is_at_weekend else 0.0
) + (
0.003 if is_at_night else 0.0
) + 0.002 * self_assured_multiplier + get_sex_autonomy_failure_chance()
def _has_outfit_parts_to_undress(interaction_sim, interaction_target,
body_types):
if interaction_target is None or not TurboTypesUtil.Sims.is_sim(
interaction_target):
return False
if not get_sex_setting(SexSetting.INSTANT_UNDRESSING_STATE,
variable_type=bool):
if not get_sex_setting(SexSetting.MANUAL_NPC_SEX_STATE,
variable_type=bool):
if sim_ev(interaction_sim).active_sex_handler is None:
return False
if sim_ev(interaction_sim).active_sex_handler is not sim_ev(
interaction_target).active_sex_handler:
return False
if sim_ev(interaction_target).active_sex_handler is None:
return False
elif sim_ev(interaction_target).active_sex_handler is None:
return False
for body_type in body_types:
body_state = get_sim_actual_body_state(interaction_target, body_type)
if body_state == BodyState.NUDE:
pass
part_id = get_sim_outfit_cas_part_from_bodytype(
interaction_target, body_type)
if part_id == -1:
pass
return False
def get_time_between_sex_autonomy_attempts():
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.HIGH:
return 360000
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.NORMAL:
return 720000
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.LOW:
return 1440000
return 0
def try_sim_pregnancy_from_sex_handler(sex_handler, sims_list, actor_id,
sim_info):
if not can_sim_get_pregnant(sim_info):
return False
if TurboSimUtil.Pregnancy.is_pregnant(sim_info):
return False
sim_pregnancy_chance = get_sim_current_pregnancy_chance(sim_info)
if get_sex_setting(
SexSetting.PREGNANCY_MODE, variable_type=int
) == PregnancyModeSetting.SIMPLE and sim_pregnancy_chance <= 0.0:
return False
pregnancy_partners = _get_possible_partners(sex_handler, sims_list,
actor_id, sim_info)
absolute_days = TurboWorldUtil.Time.get_absolute_days()
enable_pregnancy_discovery = False
for (partner_sim_id, is_cum_inside) in pregnancy_partners:
partner_sim_info = TurboManagerUtil.Sim.get_sim_info(partner_sim_id)
if partner_sim_info is None:
pass
if has_relationship_bit_with_sim(
sim_info, partner_sim_info,
SimRelationshipBit.WW_POTENTIAL_PREGNANCY_PARENT):
pass
if get_sex_setting(
SexSetting.BIRTH_CONTROL_MODE,
variable_type=int) == BirthControlModeSetting.REALISTIC:
enable_pregnancy_discovery = True
if _is_sim_on_birth_control(partner_sim_info):
pass
enable_pregnancy_discovery = True
partner_pregnancy_chance = get_sim_current_pregnancy_chance(
partner_sim_info)
if partner_pregnancy_chance <= 0.0:
pass
if is_cum_inside is False:
if has_sim_trait(partner_sim_info, SimTrait.LAZY) or has_sim_trait(
partner_sim_info, SimTrait.CLUMSY):
partner_pregnancy_chance /= 2.0
else:
partner_pregnancy_chance /= 4.0
chance_value = random.Random(
(absolute_days, TurboManagerUtil.Sim.get_sim_id(sim_info),
partner_sim_id)).uniform(0, 1)
while chance_value <= sim_pregnancy_chance and (
sim_ev(sim_info).pregnancy_fertility_boost[0] > 0
or chance_value <= partner_pregnancy_chance):
sim_ev(sim_info).pregnancy_coming_flag = True
add_relationsip_bit_with_sim(
sim_info, partner_sim_info,
SimRelationshipBit.WW_POTENTIAL_PREGNANCY_PARENT)
enable_pregnancy_discovery = True
if enable_pregnancy_discovery is True and sex_handler.has_displayed_pregnancy_notification is False:
set_sim_pregnancy_discovery(sim_info, True)
sex_handler.has_displayed_pregnancy_notification = True
def on_interaction_test(cls, interaction_context, interaction_target):
if not get_sex_setting(SexSetting.GENDER_RECOGNITION_SIM_SPECIFIC_STATE, variable_type=bool):
return False
if get_sex_setting(SexSetting.SEX_GENDER_TYPE, variable_type=int) == SexGenderTypeSetting.SEX_BASED:
return False
if interaction_target is None or not TurboTypesUtil.Sims.is_sim(interaction_target):
return False
if is_sim_in_sex(interaction_target) or is_sim_planning_for_sex(interaction_target):
return False
if sim_ev(interaction_target).gender_recognition == 0:
return False
return True
def _trigger_autonomy_join_sex_interaction(active_sex_handler, join_sim):
object_identifier = active_sex_handler.get_object_identifier()
genders = list()
sims_list = list(active_sex_handler.get_actors_sim_info_gen())
sims_list.append(join_sim)
for sim in sims_list:
genders.append(get_sim_sex_gender(sim))
target_sex_category_type = active_sex_handler.get_animation_instance(
).get_sex_category()
animation_instance = None
for sex_category_type in (target_sex_category_type,
SexCategoryType.ORALJOB, SexCategoryType.VAGINAL,
SexCategoryType.ANAL, SexCategoryType.HANDJOB,
SexCategoryType.FOOTJOB,
SexCategoryType.TEASING):
if not is_sim_allowed_for_animation(sims_list, sex_category_type):
pass
animation_instance = get_random_animation_of_type(
sex_category_type,
object_identifier,
genders,
ignore_animations=get_autonomy_disabled_sex_animations())
while animation_instance is not None:
break
if animation_instance is None:
return False
pre_sex_handler = active_sex_handler.get_pre_sex_handler(is_joining=True)
pre_sex_handler.set_animation_instance(animation_instance)
for sim in sims_list:
pre_sex_handler.add_sim(sim)
creator_sim = TurboManagerUtil.Sim.get_sim_info(
pre_sex_handler.get_creator_sim_id())
ask_player_to_start = False
if get_sex_setting(
SexSetting.AUTONOMY_PLAYER_ASK_PLAYER_DIALOG_STATE,
variable_type=bool) and TurboSimUtil.Sim.is_player(
creator_sim) and TurboSimUtil.Sim.is_player(join_sim):
ask_player_to_start = True
elif get_sex_setting(
SexSetting.AUTONOMY_NPC_ASK_PLAYER_DIALOG_STATE,
variable_type=bool) and TurboSimUtil.Sim.is_player(
creator_sim) and TurboSimUtil.Sim.is_npc(join_sim):
ask_player_to_start = True
elif get_sex_setting(
SexSetting.AUTONOMY_PLAYER_ASK_NPC_DIALOG_STATE,
variable_type=bool) and TurboSimUtil.Sim.is_npc(
creator_sim) and TurboSimUtil.Sim.is_player(join_sim):
ask_player_to_start = True
join_sex_interaction_from_pre_sex_handler(
pre_sex_handler, (join_sim, ),
ask_player_to_join=ask_player_to_start,
ignore_relationship_check=True)
return True
def get_sim_current_pregnancy_chance(sim_identifier):
if get_sex_setting(SexSetting.PREGNANCY_MODE, variable_type=int) == PregnancyModeSetting.DISABLED:
return 0.0
chance_modifier = 1.0
chance_modifier -= sim_ev(sim_identifier).birth_control_pill_power
if get_sex_setting(SexSetting.PREGNANCY_MODE, variable_type=int) == PregnancyModeSetting.SIMPLE:
if has_sim_trait(sim_identifier, SimTrait.WW_INFERTILE):
return 0.0
if TurboSimUtil.Sim.is_npc(sim_identifier):
return get_sex_setting(SexSetting.SIMPLE_NPC_PREGNANCY_CHANCE, variable_type=int)/100.0*chance_modifier
return get_sex_setting(SexSetting.SIMPLE_PREGNANCY_CHANCE, variable_type=int)/100.0*chance_modifier
elif get_sex_setting(SexSetting.PREGNANCY_MODE, variable_type=int) == PregnancyModeSetting.MENSTRUAL_CYCLE:
return get_sim_current_menstrual_pregnancy_chance(sim_identifier)*chance_modifier
return 0.0
def is_sim_allowed_for_free_birth_control(sim_identifier):
random_inst = random.Random(
TurboManagerUtil.Sim.get_sim_id(sim_identifier) /
max(1, TurboWorldUtil.Time.get_absolute_days()))
if get_sex_setting(SexSetting.NPC_BIRTH_CONTROL_MODE,
variable_type=int) == NPCBirthControlModeSetting.SAFE:
if random_inst.uniform(0, 1) > 0.1:
return True
elif get_sex_setting(
SexSetting.NPC_BIRTH_CONTROL_MODE, variable_type=int
) == NPCBirthControlModeSetting.MODERATE and random_inst.uniform(0,
1) > 0.38:
return True
return False
def _get_menstrual_cycle_duration():
if get_sex_setting(
SexSetting.MENSTRUAL_CYCLE_DURATION,
variable_type=int) == MenstrualCycleDurationSetting.AUTO:
sims_age_speed = TurboSimUtil.Age.get_global_age_speed()
if sims_age_speed == TurboSimUtil.Age.AgeSpeed.SLOW:
return MenstrualCycleDurationSetting.LONG
if sims_age_speed == TurboSimUtil.Age.AgeSpeed.NORMAL:
return MenstrualCycleDurationSetting.NORMAL
if sims_age_speed == TurboSimUtil.Age.AgeSpeed.FAST:
return MenstrualCycleDurationSetting.SHORT
return MenstrualCycleDurationSetting.NORMAL
return get_sex_setting(SexSetting.MENSTRUAL_CYCLE_DURATION,
variable_type=int)
def update_stapon(sim_identifier,
actor_data=None,
is_npc_only=False,
force_remove=False):
if not has_loaded_strapon():
return False
sim_info = TurboManagerUtil.Sim.get_sim_info(sim_identifier)
if force_remove is True and is_strapon_on_sim(sim_info):
_undress_bottom(sim_info)
return False
if is_npc_only is False:
undressing_type = get_sex_setting(SexSetting.SEX_UNDRESSING_TYPE,
variable_type=int)
else:
undressing_type = get_sex_setting(SexSetting.NPC_SEX_UNDRESSING_TYPE,
variable_type=int)
if has_sim_trait(sim_info, SimTrait.GENDEROPTIONS_TOILET_STANDING):
return False
if sim_ev(sim_info).is_strapon_allowed is False:
if get_sex_setting(SexSetting.STRAPON_AUTO_REMOVE_STATE,
variable_type=bool) and is_strapon_on_sim(sim_info):
_undress_bottom(sim_info)
return False
allows_strapon = False
if actor_data is not None and actor_data.is_allowing_strapon():
allows_strapon = True
elif actor_data is not None and (
actor_data.get_final_gender_type() == SexGenderType.MALE
or actor_data.get_final_gender_type() == SexGenderType.CMALE):
allows_strapon = True
if is_strapon_on_sim(sim_info):
if allows_strapon is False and get_sex_setting(
SexSetting.STRAPON_AUTO_REMOVE_STATE, variable_type=bool):
_undress_bottom(sim_info)
return False
return True
if allows_strapon is False:
return False
if undressing_type == SexUndressingLevelSetting.DISABLED and get_sim_actual_body_state(
sim_info, TurboCASUtil.BodyType.LOWER_BODY) != BodyState.NUDE:
return False
_undress_bottom(sim_info)
set_bodytype_caspart(sim_info, (TurboCASUtil.OutfitCategory.SPECIAL, 0),
TurboCASUtil.BodyType.LOWER_BODY,
get_sim_strapon_part_id(sim_info))
try:
TurboSimUtil.CAS.refresh_outfit(sim_info)
except:
pass
def _is_sim_fearing_possible_pregnancy(sim_identifier):
if TurboSimUtil.Sim.is_player(sim_identifier):
return False
if not can_sim_get_pregnant(sim_identifier):
return False
if is_sim_birth_control_safe(sim_identifier, allow_potentially=True):
return False
if get_sex_setting(
SexSetting.AUTONOMY_NPC_PREGNANCY_AWARENESS, variable_type=bool
) and get_sex_setting(
SexSetting.PREGNANCY_MODE, variable_type=bool
) == PregnancyModeSetting.MENSTRUAL_CYCLE and get_sim_current_pregnancy_chance(
sim_identifier) > 0:
return True
return False
def _trigger_random_sex_autonomy_on_game_update():
global SEX_AUTONOMY_LAST_HOUR_UPDATE
if get_sex_setting(SexSetting.AUTONOMY_LEVEL, variable_type=int) == SexAutonomyLevelSetting.DISABLED:
return
if not get_sex_setting(SexSetting.AUTONOMY_RANDOM_SEX_STATE, variable_type=bool):
return
if SEX_AUTONOMY_LAST_HOUR_UPDATE == -1:
SEX_AUTONOMY_LAST_HOUR_UPDATE = TurboWorldUtil.Time.get_hour_of_day()
return
if SEX_AUTONOMY_LAST_HOUR_UPDATE == TurboWorldUtil.Time.get_hour_of_day():
return
SEX_AUTONOMY_LAST_HOUR_UPDATE = TurboWorldUtil.Time.get_hour_of_day()
result = trigger_random_sex_autonomy()
if not result:
update_sex_autonomy_failure_chance(result)
def trigger_random_sex_autonomy(force=False):
result = False
is_hypersexual_lot = has_current_lot_trait(LotTrait.WW_LOTTRAIT_HYPERSEXUAL)
if is_hypersexual_lot is True:
if get_sex_setting(SexSetting.AUTONOMY_LEVEL, variable_type=int) == SexAutonomyLevelSetting.HIGH:
triggers_amount = 4
elif get_sex_setting(SexSetting.AUTONOMY_LEVEL, variable_type=int) == SexAutonomyLevelSetting.NORMAL:
triggers_amount = 3
else:
triggers_amount = 2
for _ in range(triggers_amount):
while _trigger_random_sex_autonomy(force=False, only_hypersexual_lot_sims=True):
result = True
if _trigger_random_sex_autonomy(force=force):
result = True
return result
def get_sex_autonomy_location(sims_pair,
location_style=LocationStyleType.NONE,
sex_locations_override=None):
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.HIGH:
sex_locations_sample = 8
elif get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.NORMAL:
sex_locations_sample = 6
else:
sex_locations_sample = 3
sex_locations = sex_locations_override or get_sex_locations(
sims_pair, location_style=location_style)[:sex_locations_sample]
if not sex_locations:
return
return random.choice(sex_locations)[1]
def update_sex_autonomy_failure_chance(result):
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.HIGH:
failure_chance_modifier = SEX_AUTONOMY_HIGH_LEVEL_BASE_CHANCE / 2
elif get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.NORMAL:
failure_chance_modifier = SEX_AUTONOMY_NORMAL_LEVEL_BASE_CHANCE / 2
else:
failure_chance_modifier = SEX_AUTONOMY_LOW_LEVEL_BASE_CHANCE / 2
current_autonomy_failure_chance = get_sex_autonomy_failure_chance()
if not result:
set_sex_autonomy_failure_chance(
min(current_autonomy_failure_chance + failure_chance_modifier, 1))
else:
set_sex_autonomy_failure_chance(
max(0, current_autonomy_failure_chance - failure_chance_modifier))
def get_age_limits_for_sex(sims_list):
youngest_sim_age = None
oldest_sim_age = None
for actor_sim_info in sims_list:
if actor_sim_info is None:
continue
if youngest_sim_age is None or TurboSimUtil.Age.is_younger_than(actor_sim_info, youngest_sim_age):
youngest_sim_age = TurboSimUtil.Age.get_age(actor_sim_info)
if oldest_sim_age is None or TurboSimUtil.Age.is_older_than(actor_sim_info, oldest_sim_age):
oldest_sim_age = TurboSimUtil.Age.get_age(actor_sim_info)
is_allowing_teens = get_sex_setting(SexSetting.TEENS_SEX_STATE, variable_type=bool)
is_child_only = youngest_sim_age == oldest_sim_age == TurboSimUtil.Age.CHILD
is_teen_only = youngest_sim_age == oldest_sim_age == TurboSimUtil.Age.TEEN
has_teen = youngest_sim_age == TurboSimUtil.Age.TEEN or oldest_sim_age == TurboSimUtil.Age.TEEN
has_child = youngest_sim_age == TurboSimUtil.Age.CHILD or oldest_sim_age == TurboSimUtil.Age.CHILD
if not get_relationship_setting(RelationshipSetting.ROMANCE_AGE_RESTRICTION_STATE, variable_type=bool):
if is_child_only and is_allowing_teens:
return (TurboSimUtil.Age.CHILD, TurboSimUtil.Age.CHILD)
if is_teen_only and is_allowing_teens:
return (TurboSimUtil.Age.TEEN, TurboSimUtil.Age.TEEN)
if has_child and is_allowing_teens:
return (TurboSimUtil.Age.CHILD, TurboSimUtil.Age.ELDER)
if has_teen and is_allowing_teens:
return (TurboSimUtil.Age.TEEN, TurboSimUtil.Age.ELDER)
return (TurboSimUtil.Age.YOUNGADULT, TurboSimUtil.Age.ELDER)
else:
if not CNSimUtils.teen_sex_is_enabled():
return (TurboSimUtil.Age.YOUNGADULT, TurboSimUtil.Age.ELDER)
return (TurboSimUtil.Age.CHILD, TurboSimUtil.Age.ELDER)
def modify_sim_sex_snapshot_motive(sim_info,
sim_motive,
snapshot_state,
modify_value,
min_value=None,
max_value=None):
sim_state_snapshot = sim_ev(sim_info).sim_sex_state_snapshot
if snapshot_state not in sim_state_snapshot:
return
if not get_sex_setting(SexSetting.NEEDS_DECAY_STATE, variable_type=bool):
set_sim_motive_value(sim_info,
sim_motive,
sim_state_snapshot[snapshot_state],
skip_disabled=True)
else:
motive_value = get_sim_motive_value(sim_info,
sim_motive) + modify_value
if min_value is not None and motive_value < min_value:
motive_value = min_value
if max_value is not None and motive_value > max_value:
motive_value = max_value
set_sim_motive_value(sim_info,
sim_motive,
motive_value,
skip_disabled=True)
sim_state_snapshot[snapshot_state] = motive_value
def get_animations_for_object(object_identifier,
genders,
excluded_sex_category_types=(),
ignore_animations_ids=(),
ignore_animations=()):
collected_animations = list()
for animation_instance in get_available_sex_animations():
while not animation_instance.get_sex_category(
) == SexCategoryType.NONE:
if animation_instance.get_sex_category(
) in excluded_sex_category_types:
pass
while not animation_instance.get_animation_id(
) in ignore_animations_ids:
if animation_instance.get_identifier() in ignore_animations:
pass
while len(animation_instance.get_actors()) == len(
genders
) and animation_instance.can_be_used_with_object(
object_identifier):
if get_sex_setting(SexSetting.SEX_GENDER_TYPE,
variable_type=int
) == SexGenderTypeSetting.ANY_BASED:
collected_animations.append(animation_instance)
else:
actors_genders_list = list()
for actor_data in animation_instance.get_actors():
actors_genders_list.append(
actor_data.get_gender_type())
if compare_sim_genders_with_actor_genders_list(
genders, actors_genders_list):
collected_animations.append(animation_instance)
return collected_animations
def _can_sim_receive_cum(interaction_sim, interaction_target, cum_type):
if interaction_target is None or not TurboTypesUtil.Sims.is_sim(interaction_target):
return False
if not get_sex_setting(SexSetting.MANUAL_NPC_SEX_STATE, variable_type=bool):
if sim_ev(interaction_sim).active_sex_handler is None:
return False
if sim_ev(interaction_sim).active_sex_handler is not sim_ev(interaction_target).active_sex_handler:
return False
elif sim_ev(interaction_target).active_sex_handler is None:
return False
active_sex_handler = sim_ev(interaction_target).active_sex_handler
if active_sex_handler.is_at_climax is False:
return False
if cum_type == CumLayerType.V****A and has_sim_trait(interaction_target, SimTrait.GENDEROPTIONS_TOILET_STANDING):
return False
has_sim_that_can_cum = False
for actor_sim_info in active_sex_handler.get_actors_sim_info_gen():
if TurboManagerUtil.Sim.get_sim_id(actor_sim_info) == TurboManagerUtil.Sim.get_sim_id(interaction_target):
pass
if not has_sim_trait(actor_sim_info, SimTrait.GENDEROPTIONS_TOILET_STANDING):
pass
has_sim_that_can_cum = True
break
if has_sim_that_can_cum is False:
return False
if has_sim_cas_part_id(interaction_target, get_cum_layer_cas_id(cum_type)):
return False
return True
def on_interaction_test(cls, interaction_context, interaction_target):
if interaction_target is None or not TurboTypesUtil.Sims.is_sim(
interaction_target):
return False
if not get_sex_setting(SexSetting.MANUAL_NPC_SEX_STATE,
variable_type=bool):
if sim_ev(cls.get_interaction_sim(
interaction_context)).active_sex_handler is None:
return False
if sim_ev(cls.get_interaction_sim(
interaction_context)).active_sex_handler is not sim_ev(
interaction_target).active_sex_handler:
return False
elif sim_ev(interaction_target).active_sex_handler is None:
return False
active_sex_handler = sim_ev(interaction_target).active_sex_handler
target_actor_id = active_sex_handler.get_actor_id_by_sim_id(
TurboManagerUtil.Sim.get_sim_id(interaction_target))
target_actor_data = active_sex_handler.get_animation_instance(
).get_actor(target_actor_id)
if target_actor_data is None:
return False
for (actor_id, actor_sim) in active_sex_handler.get_sims_list():
if actor_id == target_actor_id:
pass
actor_data = active_sex_handler.get_animation_instance().get_actor(
actor_id)
if actor_data is None:
return False
while is_compatible_actor(actor_sim, actor_data,
interaction_target, target_actor_data):
return True
return False
def _after_sex_dress_up(sim_info):
if get_sex_setting(SexSetting.OUTFIT_AUTO_DRESS_UP_AFTER_SEX_STATE,
variable_type=bool):
dress_up_outfit(sim_info)
elif TurboSimUtil.Sim.is_npc(sim_info) and has_sim_situations(
sim_info, (SimSituation.LEAVE, SimSituation.LEAVE_NOW_MUST_RUN,
SimSituation.SINGLESIMLEAVE)):
dress_up_outfit(sim_info)
def start_sex_interaction_from_pre_sex_handler(pre_sex_handler):
is_instant = get_sex_setting(
SexSetting.ALWAYS_ACCEPT_STATE,
variable_type=bool) and get_sex_setting(
SexSetting.SEX_INITIATION_TYPE,
variable_type=int) == SexInitiationTypeSetting.INSTANT_TELEPORT
if pre_sex_handler.get_sims_amount() == 1:
if is_instant is True:
return _start_instant_solo_sex_interaction(pre_sex_handler)
return _start_solo_sex_interaction(pre_sex_handler)
else:
creator_sim = TurboManagerUtil.Sim.get_sim_instance(
pre_sex_handler.get_creator_sim_id())
target_sim = TurboManagerUtil.Sim.get_sim_instance(
pre_sex_handler.get_second_sim_id())
if creator_sim is None or target_sim is None:
clear_sim_sex_extra_data(
TurboManagerUtil.Sim.get_sim_info(
pre_sex_handler.get_creator_sim_id()))
clear_sim_sex_extra_data(
TurboManagerUtil.Sim.get_sim_info(
pre_sex_handler.get_second_sim_id()))
return False
ask_player_to_start = False
if get_sex_setting(SexSetting.AUTONOMY_PLAYER_ASK_PLAYER_DIALOG_STATE,
variable_type=bool) and (
pre_sex_handler.is_autonomy_sex()
and TurboSimUtil.Sim.is_player(creator_sim)
) and TurboSimUtil.Sim.is_player(target_sim):
ask_player_to_start = True
elif get_sex_setting(
SexSetting.AUTONOMY_NPC_ASK_PLAYER_DIALOG_STATE,
variable_type=bool) and TurboSimUtil.Sim.is_npc(
creator_sim) and TurboSimUtil.Sim.is_player(target_sim):
ask_player_to_start = True
elif get_sex_setting(SexSetting.AUTONOMY_PLAYER_ASK_NPC_DIALOG_STATE,
variable_type=bool) and (
pre_sex_handler.is_autonomy_sex()
and TurboSimUtil.Sim.is_player(creator_sim)
) and TurboSimUtil.Sim.is_npc(target_sim):
ask_player_to_start = True
if is_instant is True:
return _start_instant_group_sex_interaction(
pre_sex_handler, ask_player_to_start=ask_player_to_start)
return _start_group_sex_interaction(
pre_sex_handler, ask_player_to_start=ask_player_to_start)
def _try_trigger_sim_miscarriage(sim_identifier):
if not get_sex_setting(SexSetting.MISCARRIAGE_SWITCH, variable_type=bool):
return False
if not TurboSimUtil.Pregnancy.is_pregnant(sim_identifier):
return False
if has_sim_buffs(sim_identifier, MISCARRIAGE_DISALLOWED_PREGNANCY_BUFFS):
return False
if not has_sim_buffs(sim_identifier, MISCARRIAGE_ALLOWED_PREGNANCY_BUFFS):
return False
pregnancy_days = get_sex_setting(SexSetting.PREGNANCY_DURATION,
variable_type=int)
miscarriage_potential_pregnancy_hours = 0.72 * pregnancy_days * 24
miscarriage_chance = sim_ev(
sim_identifier
).miscarriage_potential / 3.8 / miscarriage_potential_pregnancy_hours
if random.uniform(0, 1) >= miscarriage_chance:
return False
if remove_sim_pregnancy(sim_identifier):
add_sim_buff(sim_identifier,
SimBuff.WW_PREGNANCY_MISCARRIAGE,
reason=3245985980)
TurboSimUtil.Interaction.push_affordance(
sim_identifier,
SimInteraction.WW_PREGNANCY_MISCARRIAGE,
interaction_context=TurboInteractionUtil.InteractionContext.
SOURCE_SCRIPT,
insert_strategy=TurboInteractionUtil.QueueInsertStrategy.NEXT,
must_run_next=True,
priority=TurboInteractionUtil.Priority.Critical,
run_priority=TurboInteractionUtil.Priority.Critical)
miscarriage_puddle_object = TurboObjectUtil.GameObject.create_object(
12327982570318338407)
if miscarriage_puddle_object:
TurboObjectUtil.Puddle.place_puddle(miscarriage_puddle_object,
sim_identifier)
TurboWorldUtil.Time.set_current_time_speed(
TurboWorldUtil.Time.ClockSpeedMode.NORMAL)
display_notification(text=1234477375,
text_tokens=(sim_identifier, ),
title=971885236,
visual_type=TurboUIUtil.Notification.
UiDialogNotificationVisualType.SPECIAL_MOMENT,
secondary_icon=sim_identifier)
TurboUIUtil.Camera.move_to_sim(sim_identifier)
_sim_miscarriage_reaction(sim_identifier)
def on_interaction_test(cls, interaction_context, interaction_target):
if interaction_target is None or not TurboTypesUtil.Sims.is_sim(
interaction_target):
return False
if get_sex_setting(SexSetting.INSTANT_UNDRESSING_STATE,
variable_type=bool):
return True
interaction_sim = cls.get_interaction_sim(interaction_context)
if not get_sex_setting(SexSetting.MANUAL_NPC_SEX_STATE,
variable_type=bool):
if sim_ev(interaction_sim).active_sex_handler is None:
return False
if sim_ev(interaction_sim).active_sex_handler is not sim_ev(
interaction_target).active_sex_handler:
return False
elif sim_ev(interaction_target).active_sex_handler is None:
return False
return True
def _trigger_autonomy_joining_to_sex_on_game_update():
if get_sex_setting(SexSetting.AUTONOMY_LEVEL,
variable_type=int) == SexAutonomyLevelSetting.DISABLED:
return
if not get_sex_setting(SexSetting.JOIN_SEX_AUTONOMY_STATE,
variable_type=bool):
return
registered_sex_handlers = get_active_sex_handlers()
if not registered_sex_handlers:
return
for sim in get_available_for_sex_sims(
forbidden_traits=(SimTrait.WW_CUCKOLD, )):
for sex_handler in registered_sex_handlers:
while not (sex_handler.is_playing is False
or sex_handler.is_ready_to_unregister is True):
if sex_handler.has_joining_sims is True:
pass
if sex_handler.has_reached_autonomy_actors_limit():
pass
if TurboManagerUtil.Sim.get_sim_id(
sim) in sex_handler.ignore_autonomy_join_sims:
pass
creator_sim = TurboManagerUtil.Sim.get_sim_info(
sex_handler.get_creator_sim_id())
if not get_sex_setting(
SexSetting.PLAYER_JOIN_SEX_AUTONOMY_STATE,
variable_type=bool) and TurboSimUtil.Sim.is_player(
creator_sim):
pass
if TurboMathUtil.Position.get_distance(
TurboSimUtil.Location.get_position(sim),
sex_handler.get_route_position()) > 6.0:
pass
has_passed_relationship_tests = True
for target in sex_handler.get_actors_sim_info_gen():
while get_sex_pair_score(
target,
sim) < get_relationship_sex_acceptance_threshold():
has_passed_relationship_tests = False
break
if has_passed_relationship_tests is False:
pass
while _trigger_autonomy_join_sex_interaction(sex_handler, sim):
return
