def on_setup_game(self, game_object):
for (target_object, parent_slot) in self.objects.items():
bone_name_hash = None
slot_types = None
if isinstance(parent_slot, str):
bone_name_hash = sims4.hash_util.hash32(parent_slot)
else:
slot_types = {parent_slot}
for runtime_slot in game_object.get_runtime_slots_gen(
slot_types=slot_types, bone_name_hash=bone_name_hash):
valid_object_in_slot = False
child_objects = runtime_slot.children
for child in child_objects:
if child.definition.id != target_object.id:
logger.warn(
'Incorrect object {} already in slot {} of game object {}',
child, parent_slot, game_object)
child.set_parent(None)
child.destroy(
source=self,
cause=
'GameComponent: Invalid object in slot being destroyed.'
)
else:
valid_object_in_slot = True
if not valid_object_in_slot and runtime_slot.is_valid_for_placement(
definition=target_object,
objects_to_ignore=child_objects):
runtime_slot.add_child(create_object(target_object))
else:
logger.warn(
"The target object {} slot {} isn't valid for placement",
game_object,
parent_slot,
owner='nbaker')
def _spawn_fire(self, transform, routing_surface, run_placement_tests=True):
if not fire_enabled:
logger.info('Trying to spawn fire when fire is disabled. Please use |fire.toggle_enabled cheat to turn fire on.')
return
if not services.active_lot().is_position_on_lot(transform.translation):
logger.info('Trying to spawn fire on a lot other than the active lot.')
return
if not services.venue_service().venue.allows_fire:
logger.info("Trying to spawn a fire on a venue that doesn't allow fire.")
return
if not (run_placement_tests and self._placement_tests(transform.translation, routing_surface.secondary_id)):
logger.info('Trying to spawn a fire on a lot at a position that is not valid.')
return
fire_object = system.create_object(self.FIRE_OBJECT_DEF)
fire_object.move_to(transform=transform, routing_surface=routing_surface)
first_fire_on_lot = False if self._fire_objects else True
self._fire_objects.add(fire_object)
fire_object.add_state_changed_callback(self._fire_object_state_changed_callback)
self.start_objects_burning(fire_object)
self.add_scorch_mark(fire_object.position, fire_object.location.level)
self._derail_routing_sims_if_necessary(fire_object)
if first_fire_on_lot:
self._start_fire_situations()
self.activate_fire_alarms()
self.activate_sprinkler_system()
self._show_fire_notification()
self._create_or_replace_scorch_cleanup_alarm()
services.get_persistence_service().lock_save(self)
self.register_for_sim_active_lot_status_changed_callback()
if self._fire_spread_alarm is None:
time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_INTIAL_TIME_IN_SIM_MINUTES)
repeating_time_span = date_and_time.create_time_span(minutes=self.FIRE_SPREAD_REPEATING_TIME_IN_SIM_MINUTES)
self._fire_spread_alarm = alarms.add_alarm(self, time_span, self._fire_spread_alarm_callback, repeating=True, repeating_time_span=repeating_time_span)
def setup_game(self):
self.requires_setup = False
if self.target_object is not None:
return
if gsi_handlers.game_component_handlers.game_log_archiver.enabled:
setup_str = 'Game ' + str(self.current_game) + ' has been set up'
gsi_handlers.game_component_handlers.archive_game_log_entry(
self.target_object, setup_str)
self.clear_scores()
slot_hash = None
alternate_target_object = self.current_game.alternate_target_object
parent_slot = alternate_target_object.parent_slot
if isinstance(parent_slot, str):
slot_hash = sims4.hash_util.hash32(parent_slot)
for child in get_child_objects(self.owner):
while child.definition is alternate_target_object.target_game_object:
slot = child.parent_slot
if slot_hash is not None:
if slot_hash == slot.slot_name_hash:
self.target_object = child
return
if parent_slot in slot.slot_types:
self.target_object = child
return
elif parent_slot in slot.slot_types:
self.target_object = child
return
created_object = create_object(
alternate_target_object.target_game_object)
self.target_object = created_object
self.owner.slot_object(parent_slot=parent_slot,
slotting_object=created_object)
def create_spawned_object(cls,
inst,
mother,
definition,
loc_type=ItemLocation.ON_LOT):
scale = GardeningTuning.SCALE_COMMODITY.default_value
child = None
try:
child = create_object(definition, loc_type=loc_type)
gardening_component = child.get_component(
types.GARDENING_COMPONENT)
if not gardening_component.is_shoot and mother.has_state(
GardeningTuning.QUALITY_STATE_VALUE):
quality_state = mother.get_state(
GardeningTuning.QUALITY_STATE_VALUE)
child.set_state(quality_state.state, quality_state)
scale *= GardeningTuning.SCALE_VARIANCE.random_float()
child.set_stat_value(GardeningTuning.SCALE_COMMODITY, scale)
mother.spawner_component._spawned_objects.add(child)
except:
logger.exception('Failed to spawn.')
if child is not None:
child.destroy(source=mother,
cause='Exception spawning child fruit.')
child = None
return child
def on_choice_selected(self, choice_tag, **kwargs):
mother = choice_tag
if mother is None:
return
father = self.target
transferable_states = {}
for state in self._combine_data.states_to_combine:
mother_state = mother.get_state(state)
father_state = father.get_state(state)
transferable_states[state] = [mother_state, father_state]
for combine_data in self._combine_data.combination_mapping:
if combine_data.father_state == father_state and combine_data.mother_state == mother_state:
transferable_states[state].append(
combine_data.resulting_state)
if not transferable_states:
logger.error(
'CollectionPickerInteraction: {} and {} collectibles have no transferable states',
mother,
father,
owner='camilogarcia')
return
states_to_transfer = []
for states in transferable_states.values():
states_to_transfer.append(sims4.random.random.choice(states))
target_match = len(states_to_transfer)
possible_outcomes = []
for collectable in self._collectible_data:
match = 0
for target_states in collectable.collectable_item.cls._components.state._tuned_values.states:
if target_states.default_value in states_to_transfer:
match += 1
if match == target_match:
possible_outcomes.append(collectable.collectable_item)
if not possible_outcomes:
logger.error(
'CollectionPickerInteraction: No possible result when combining {} and {}',
mother,
father,
owner='camilogarcia')
return
definition_to_create = sims4.random.random.choice(possible_outcomes)
obj = create_object(definition_to_create)
if obj is None:
logger.error(
'CollectionPickerInteraction: Failed to create object when combining {} and {}',
mother,
father,
owner='camilogarcia')
return
obj.update_ownership(self.sim.sim_info)
if not self.sim.inventory_component.player_try_add_object(obj):
obj.set_household_owner_id(services.active_household_id())
if not build_buy.move_object_to_household_inventory(
obj,
object_location_type=ObjectOriginLocation.SIM_INVENTORY):
logger.error(
'CollectionPickerInteraction: Failed to add object {} to household inventory.',
obj,
owner='rmccord')
self._push_continuation(obj)
def purchase_to_inventory(inventory_obj,
def_id: str = None,
mailman_purchase: bool = False,
_connection=None):
definition_manager = services.definition_manager()
definition = definition_manager.get(def_id)
if definition is None:
return False
client = services.client_manager().get(_connection)
if client is None:
return False
household = client.household
price = definition.price
if household.funds.money < price:
return False
if mailman_purchase:
obj = services.active_lot().create_object_in_hidden_inventory(
definition)
else:
inventory = inventory_obj.get_target().inventory_component
if inventory is None:
return False
obj = create_object(definition)
if obj is None:
return False
if not inventory.player_try_add_object(obj):
obj.destroy(source=inventory,
cause='Failed to purchase object into inventory')
return False
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True,
active_household_id=services.active_household_id())
household.funds.remove(price, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def on_zone_load(self):
global _ocean_object
if _ocean_object is None:
beach_locator_def = OceanTuning.get_beach_locator_definition()
if beach_locator_def is None:
return
locator_manager = services.locator_manager()
locators = locator_manager.get(beach_locator_def.id)
if not locators:
return
def move_ocean(ocean):
zone = services.current_zone()
terrain_center = zone.lot.center
location = sims4.math.Location(
sims4.math.Transform(
translation=terrain_center,
orientation=sims4.math.Quaternion.IDENTITY()),
routing_surface=SurfaceIdentifier(
zone.id, 0, SurfaceType.SURFACETYPE_WORLD))
ocean.location = location
from objects.system import create_object
_ocean_object = create_object(
TerrainService.OCEAN_DEFINITION,
post_add=move_ocean,
loc_type=ItemLocation.FROM_OPEN_STREET)
def _create_automatic_objects(self, venue_tuning):
zone = services.current_zone()
for tag_pair in venue_tuning.automatic_objects:
try:
existing_objects = set(
zone.object_manager.get_objects_with_tag_gen(tag_pair.tag))
while not existing_objects:
obj = create_object(tag_pair.default_value)
position = zone.lot.corners[1]
position += vector_normalize(zone.lot.position - position)
fgl_context = FindGoodLocationContext(
starting_position=position,
object_id=obj.id,
ignored_object_ids=(obj.id, ),
search_flags=placement.FGLSearchFlagsDefault
| placement.FGLSearchFlag.SHOULD_TEST_BUILDBUY,
object_footprints=(obj.get_footprint(), ))
(position, orientation) = find_good_location(fgl_context)
if position is not None:
obj.location = sims4.math.Location(
sims4.math.Transform(position, orientation),
routing.SurfaceIdentifier(
zone.id, 0, routing.SURFACETYPE_WORLD))
else:
obj.destroy(
source=zone,
cause=
'Failed to place automatic object required by venue.'
)
except:
logger.error(
'Automatic object {} could not be created in venue {} (zone: {}).',
obj_definition, venue_tuning, zone)
def _germinate(self):
plant = None
try:
plant = create_object(self.plant)
location = self._find_germinate_location(plant)
if location is None:
logger.warn('Failed to germinate: No location found')
plant.destroy(source=self.owner, cause='Failed to germinate: No location found')
plant = None
return False
if self.owner.parent_slot is not None:
self.owner.parent_slot.add_child(plant)
else:
plant.location = location
plant.gardening_component.add_fruit(self.owner, sprouted_from=True)
created_object_quality = self.owner.get_state(GardeningTuning.QUALITY_STATE_VALUE)
current_household = services.owning_household_of_active_lot()
if current_household is not None:
plant.set_household_owner_id(current_household.id)
services.get_event_manager().process_events_for_household(test_events.TestEvent.ItemCrafted, current_household, crafted_object=plant, skill=None, quality=created_object_quality, masterwork=None)
if self.owner.in_use:
self.owner.transient = True
else:
self.owner.destroy(source=self.owner, cause='Successfully germinated.')
return
except:
logger.exception('Failed to germinate.')
if plant is not None:
plant.destroy(source=self.owner, cause='Failed to germinate.')
plant = None
return False
return plant
def purchase_to_inventory(inventory_obj, def_id:str=None, mailman_purchase:bool=False, _connection=None):
definition_manager = services.definition_manager()
definition = definition_manager.get(def_id)
if definition is None:
return False
client = services.client_manager().get(_connection)
if client is None:
return False
household = client.household
price = definition.price
if household.funds.money < price:
return False
if mailman_purchase:
obj = services.active_lot().create_object_in_hidden_inventory(definition)
else:
inventory = inventory_obj.get_target().inventory_component
if inventory is None:
return False
obj = create_object(definition)
if obj is None:
return False
if not inventory.player_try_add_object(obj):
obj.destroy(source=inventory, cause='Failed to purchase object into inventory')
return False
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True, active_household_id=services.active_household_id())
household.funds.remove(price, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def create_and_place_baby(sim_info, **kwargs):
bassinet = create_object(Baby.get_default_baby_def(), obj_id=sim_info.sim_id)
bassinet.set_sim_info(sim_info, **kwargs)
def try_to_place_bassinet(position, **kwargs):
fgl_context = placement.FindGoodLocationContext(starting_position=position, object_id=sim_info.sim_id, search_flags=placement.FGLSearchFlagsDefault | placement.FGLSearchFlag.SHOULD_TEST_BUILDBUY, object_footprints=(bassinet.get_footprint(),), **kwargs)
(translation, orientation) = placement.find_good_location(fgl_context)
if translation is not None and orientation is not None:
bassinet.move_to(translation=translation, orientation=orientation)
return True
return False
lot = services.active_lot()
for tag in Baby.BABY_PLACEMENT_TAGS:
for (attempt, obj) in enumerate(services.object_manager().get_objects_with_tag_gen(tag)):
position = obj.position
if lot.is_position_on_lot(position) and try_to_place_bassinet(position, max_distance=10):
return
while attempt >= Baby.MAX_PLACEMENT_ATTEMPTS:
break
position = lot.get_default_position()
if not try_to_place_bassinet(position):
bassinet.update_ownership(sim_info, make_sim_owner=False)
build_buy.move_object_to_household_inventory(bassinet)
if sim_info.is_selectable:
failed_placement_notification = Baby.FAILED_PLACEMENT_NOTIFICATION(sim_info, SingleSimResolver(sim_info))
failed_placement_notification.show_dialog()
def _replace_bassinet(sim_info, bassinet=None):
bassinet = bassinet if bassinet is not None else services.object_manager().get(sim_info.sim_id)
if bassinet is not None:
empty_bassinet = create_object(Baby.get_corresponding_definition(bassinet.definition))
empty_bassinet.location = bassinet.location
bassinet.destroy(source=sim_info, cause='Replaced bassinet with empty version')
return empty_bassinet
def setup_game(self):
self.requires_setup = False
if self.target_object is not None:
return
if gsi_handlers.game_component_handlers.game_log_archiver.enabled:
setup_str = 'Game ' + str(self.current_game) + ' has been set up'
gsi_handlers.game_component_handlers.archive_game_log_entry(self.target_object, setup_str)
self.clear_scores()
slot_hash = None
alternate_target_object = self.current_game.alternate_target_object
parent_slot = alternate_target_object.parent_slot
if isinstance(parent_slot, str):
slot_hash = sims4.hash_util.hash32(parent_slot)
for child in get_child_objects(self.owner):
while child.definition is alternate_target_object.target_game_object:
slot = child.parent_slot
if slot_hash is not None:
if slot_hash == slot.slot_name_hash:
self.target_object = child
return
if parent_slot in slot.slot_types:
self.target_object = child
return
elif parent_slot in slot.slot_types:
self.target_object = child
return
created_object = create_object(alternate_target_object.target_game_object)
self.target_object = created_object
self.owner.slot_object(parent_slot=parent_slot, slotting_object=created_object)
def debug_create_baby(actor_sim, position, gender, routing_surface=None):
baby = None
try:
actor_sim_info = actor_sim.sim_info
account = actor_sim.sim_info.account
sim_creator = SimCreator(gender=gender, age=Age.BABY, first_name=SimSpawner.get_random_first_name(account, gender == Gender.FEMALE), last_name=SimSpawner.get_family_name_for_gender(account, actor_sim.last_name, gender == Gender.FEMALE))
(sim_info_list, _) = SimSpawner.create_sim_infos((sim_creator,), household=actor_sim_info.household, account=account, zone_id=actor_sim_info.zone_id, creation_source='cheat: debug_create_baby')
sim_info = sim_info_list[0]
baby_def = Baby.get_default_baby_def()
baby = create_object(baby_def, sim_info.sim_id)
baby.set_sim_info(sim_info)
fgl_context = placement.FindGoodLocationContext(starting_position=position, object_id=baby.id, search_flags=placement.FGLSearchFlagsDefault, object_footprints=(baby.get_footprint(),))
(trans, orient) = placement.find_good_location(fgl_context)
if trans is not None:
baby.location = sims4.math.Location(sims4.math.Transform(trans, orient), routing_surface)
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
while client is not None:
client.selectable_sims.add_selectable_sim_info(sim_info)
except Exception as e:
logger.exception('Create baby fail', e)
if actor_sim_info.household.sim_in_household(sim_info.sim_id):
actor_sim_info.household.remove_sim_info(sim_info)
client = services.client_manager().get_client_by_household_id(sim_info.household_id)
if client is not None:
client.selectable_sims.remove_selectable_sim_info(sim_info)
while baby is not None:
baby.destroy(source=actor_sim, cause='Create baby fail')
def _create(_):
self._object = create_object(self.def_id, **self.create_kwargs)
if self._object is None:
return False
if self.sim is not None and self._reserver is not None:
self.object.reserve(self.sim, self._reserver)
return True
def create_object_in_hidden_inventory(self, definition_id):
inventory = self.get_hidden_inventory()
obj = create_object(definition_id, loc_type=ItemLocation.OBJECT_INVENTORY)
try:
inventory.system_add_object(obj, None)
return obj
except:
obj.destroy(source=self, cause='Failed to place object in hidden inventory.')
def _replace_bassinet_for_age_up(sim_info):
bassinet = services.object_manager().get(sim_info.sim_id)
if bassinet is not None:
new_bassinet = create_object(bassinet.definition)
new_bassinet.location = bassinet.location
new_bassinet.set_sim_info(bassinet.sim_info)
new_bassinet.copy_state_values(bassinet, state_list=Baby.BABY_AGE_UP.copy_states)
bassinet.destroy(source=sim_info, cause='Replacing bassinet for age up.')
return new_bassinet
def create_spawned_object(cls,
inst,
spawner_object,
definition,
loc_type=ItemLocation.ON_LOT):
obj = create_object(definition, loc_type=loc_type)
if obj is not None:
spawner_object.spawner_component._spawned_objects.add(obj)
return obj
def create_and_place_baby(sim_info,
position=None,
routing_surface=None,
**kwargs):
bassinet = create_object(BabyTuning.get_default_definition(sim_info),
obj_id=sim_info.sim_id)
bassinet.set_sim_info(sim_info, **kwargs)
bassinet.place_in_good_location(position=position,
routing_surface=routing_surface)
sim_info.suppress_aging()
def _create_object_rewards(self, obj_weight_pair, obj_counter, resolver):
obj_result = weighted_random_item(obj_weight_pair)
for obj_reward in obj_result:
created_obj = create_object(
obj_reward,
init=None,
post_add=lambda *args: self._place_object(resolver=resolver,
*args))
while created_obj is not None:
obj_counter[obj_reward] += 1
def _replace_bassinet(sim_info, bassinet=None):
bassinet = bassinet if bassinet is not None else services.object_manager(
).get(sim_info.sim_id)
if bassinet is not None:
empty_bassinet = create_object(
Baby.get_corresponding_definition(bassinet.definition))
empty_bassinet.location = bassinet.location
bassinet.destroy(source=sim_info,
cause='Replaced bassinet with empty version')
return empty_bassinet
def create_object(self):
created_object = create_object(self.definition,
init=self._setup_created_object,
post_add=self._place_object)
if self._placement_failed:
created_object.destroy(
source=self.interaction,
cause='Failed to place object created by basic extra.')
return
return created_object
def create_object_in_hidden_inventory(self, definition_id):
inventory = self.get_hidden_inventory()
obj = create_object(definition_id,
loc_type=ItemLocation.OBJECT_INVENTORY)
try:
inventory.system_add_object(obj, None)
return obj
except:
obj.destroy(source=self,
cause='Failed to place object in hidden inventory.')
def __call__(self, sim):
def _abort(vehicle_obj):
sim.allow_opacity_change = True
sim.fade_in()
if vehicle_obj is not None:
vehicle_obj.destroy()
vehicle = None
if sim.sim_info.favorites_tracker is not None:
favorites_tracker = sim.sim_info.favorites_tracker
definition_manager = services.definition_manager()
vehicle_def_id = favorites_tracker.get_favorite_definition_id(
self.vehicle_obj_tag)
if vehicle_def_id is not None:
vehicle_def = definition_manager.get(vehicle_def_id)
if vehicle_def is not None:
vehicle = objects.system.create_object(vehicle_def)
if vehicle is None:
if self.fallback_vehicle_def is None:
_abort(vehicle)
return True
vehicle = create_object(self.fallback_vehicle_def)
if vehicle is None:
_abort(vehicle)
return True
vehicle.set_household_owner_id(sim.household_id)
starting_location = placement.create_starting_location(
position=sim.position)
fgl_context = placement.create_fgl_context_for_object(
starting_location, vehicle)
(position, orientation) = placement.find_good_location(fgl_context)
if position is None or orientation is None:
_abort(vehicle)
return True
vehicle.transform = sims4.math.Transform(position, orientation)
result = vehicle.vehicle_component.push_drive_affordance(
sim, priority=Priority.Critical)
if result is None:
_abort(vehicle)
return True
if result.interaction is None:
logger.warn(
"Vehicle's push drive affordance {} resulted in a None interaction. Result: {}.",
vehicle.vehicle_component.drive_affordance,
result,
owner='jmorrow')
_abort(vehicle)
return True
sim.fade_in()
vehicle.claim()
for situation in services.get_zone_situation_manager().get_all():
if sim in situation.all_sims_in_situation_gen():
situation.manage_vehicle(vehicle)
break
return True
def _replace_bassinet_for_age_up(sim_info):
bassinet = services.object_manager().get(sim_info.sim_id)
if bassinet is not None:
new_bassinet = create_object(bassinet.definition)
new_bassinet.location = bassinet.location
new_bassinet.set_sim_info(bassinet.sim_info)
new_bassinet.copy_state_values(bassinet,
state_list=Baby.BABY_AGE_UP.copy_states)
bassinet.destroy(source=sim_info,
cause='Replacing bassinet for age up.')
return new_bassinet
def _add_starting_objects(self):
for definition in self._starting_objects:
if self._inventory.has_item_with_definition(definition):
pass
new_object = create_object(definition)
if not new_object:
logger.error('Failed to create object {}', definition)
if not self.player_try_add_object(new_object):
logger.error('Failed to add object {} to inventory {}', new_object, self)
new_object.destroy(source=self.owner, cause='Failed to add starting object to inventory.')
new_object.set_household_owner_id(self.owner.get_household_owner_id())
def _add_starting_objects(self):
for definition in self.starting_objects:
if self.has_item_with_definition(definition):
continue
new_object = create_object(definition, loc_type=ItemLocation.OBJECT_INVENTORY)
if new_object is None:
logger.error('Failed to create object {}', definition)
else:
new_object.set_household_owner_id(self.owner.get_household_owner_id())
if not self.player_try_add_object(new_object):
logger.error('Failed to add object {} to inventory {}', new_object, self)
new_object.destroy(source=self.owner, cause='Failed to add starting object to inventory.')
def _pre_perform(self, *args, **kwargs):
bassinet_def = BabyTuning.get_corresponding_definition(
self.bassinet_to_use)
self._bassinet = create_object(bassinet_def)
surgery_table = self.get_participant(
self.surgery_table_participant_type)
if surgery_table is None:
logger.error('No surgery table found for {}', self, owner='tastle')
return False
surgery_table.part_owner.slot_object(self.bassinet_slot_type,
self._bassinet)
return True
def create_and_add_object_to_inventory(to_inventory_object_id:RequiredTargetParam, definition_id:int, _connection=None):
to_inventory_owner = to_inventory_object_id.get_target()
to_inventory = to_inventory_owner.inventory_component
if to_inventory is None:
sims4.commands.output('to inventory object does not have an inventory component: {}'.format(to_inventory_owner), _connection)
return False
obj = create_object(definition_id)
if not to_inventory.player_try_add_object(obj):
sims4.commands.output('object failed to be placed into inventory: {}'.format(obj), _connection)
obj.destroy(source=to_inventory, cause='object failed to be placed into inventory')
return False
sims4.commands.output('object {} placed into inventory'.format(obj), _connection)
return True
def _return_lost_object(self, locator):
sim_info = services.sim_info_manager().get(locator.sim_id)
object_id = locator.object_data.object_id
if sim_info is not None and sim_info.is_instanced():
if sim_info.zone_id != locator.zone_id and not self._any_household_member_on_lot(
locator.zone_id, sim_info.household.id, sim_info.id):
sim = sim_info.get_sim_instance(
allow_hidden_flags=ALL_HIDDEN_REASONS)
if sim is None:
return (None, None)
obj = create_object(locator.object_data.guid,
loc_type=ItemLocation.SIM_INVENTORY)
if obj is not None:
obj.attributes = locator.object_data.SerializeToString()
obj.scale = locator.object_data.scale
if sim.inventory_component.player_try_add_object(obj):
obj.update_ownership(sim_info)
self.remove_object(object_id)
self.add_clone_id(locator.zone_id,
locator.open_street_id, object_id)
return (obj, sim)
obj.destroy(
source=self,
cause='Failed to add object to Sim Inv, try later')
return (None, None)
elif sim_info is None and not self._any_household_member_on_lot(
locator.zone_id, locator.household_id, locator.sim_id):
obj = create_object(locator.object_data.guid,
loc_type=ItemLocation.HOUSEHOLD_INVENTORY)
if obj is not None:
obj.attributes = locator.object_data.SerializeToString()
obj.scale = locator.object_data.scale
if build_buy.move_object_to_household_inventory(
obj, HouseholdInventoryFlags.FORCE_OWNERSHIP):
self.remove_object(object_id)
self.add_clone_id(locator.zone_id, locator.open_street_id,
object_id)
return (obj, locator.household_id)
return (None, None)
def create_object_in_mailbox(self, definition_id, household_id):
inventory = self.get_mailbox_inventory(household_id)
if inventory is None:
return
obj = create_object(definition_id,
loc_type=ItemLocation.OBJECT_INVENTORY)
if household_id is not None:
obj.set_household_owner_id(household_id)
try:
inventory.system_add_object(obj)
return obj
except:
obj.destroy(source=self,
cause='Failed to place object in mailbox.')
def _try_create_in_sim_inventory(
self,
sim_info,
obj=None,
force_rewards_to_sim_info_inventory=False):
sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS)
if sim is None:
if force_rewards_to_sim_info_inventory:
obj = create_object(self._definition) if obj is None else obj
return sim_info.try_add_object_to_inventory_without_component(
obj)
return (False, None)
obj = create_object(self._definition) if obj is None else obj
if obj is None:
logger.error(
'Trying to give an object reward to a Sim, {}, and the object created was None. Definition: {}',
sim_info, self._definition)
return (False, None)
result = sim.inventory_component.player_try_add_object(obj)
if not result:
return (False, obj)
obj.update_ownership(sim_info)
return (True, obj)
def open_reward(self, sim_info, is_household):
obj = create_object(self._definition)
if obj is None:
logger.error('Trying to give an object reward to a Sim, {}, and the object created was None. Definition: {}'.format(sim_info, self._definition), owner='trevorlindsey')
return
if not is_household:
sim = sim_info.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS)
if sim is None:
logger.warn("Trying to give a sim an object, but the sim isn't instantiated. Adding object to household inventory instead", owner='trevorlindsey')
elif sim.inventory_component.player_try_add_object(obj):
obj.update_ownership(sim_info)
return
obj.update_ownership(sim_info, make_sim_owner=False)
obj.set_post_bb_fixup_needed()
build_buy.move_object_to_household_inventory(obj)
def replace_bassinet(sim_info, bassinet=None, safe_destroy=False):
bassinet = bassinet if bassinet is not None else services.object_manager(
).get(sim_info.sim_id)
if bassinet is not None:
empty_bassinet = create_object(
BabyTuning.get_corresponding_definition(bassinet.definition))
empty_bassinet.location = bassinet.location
if safe_destroy:
bassinet.make_transient()
else:
bassinet.reset(ResetReason.RESET_EXPECTED, None,
'Replacing Bassinet with child')
bassinet.destroy(source=sim_info,
cause='Replaced bassinet with empty version')
return empty_bassinet
def _create_and_establish_familiar_link(self):
sim = self._owner.get_sim_instance(allow_hidden_flags=ALL_HIDDEN_REASONS_EXCEPT_UNINITIALIZED)
if sim is None:
return
familiar_type = self._familiars[self._active_familiar_id].familiar_type
familiar_data = FamiliarTracker.FAMILIAR_DATA[familiar_type]
if familiar_data.familiar_type is None:
try:
self._active_familiar_obj_id = self._familiars[self._active_familiar_id].pet_familiar_id
pet_familiar_sim_info = services.sim_info_manager().get(self._active_familiar_obj_id)
buff_info_to_add = self.PET_FAMILIAR_BUFF[pet_familiar_sim_info.age][pet_familiar_sim_info.extended_species]
self._pet_buff_handle = pet_familiar_sim_info.add_buff(buff_info_to_add.buff_type, buff_reason=buff_info_to_add.buff_reason)
pet_familiar = services.object_manager().get(self._active_familiar_obj_id)
if services.current_zone().is_zone_running:
if pet_familiar is None:
services.current_zone().venue_service.active_venue.summon_npcs((pet_familiar_sim_info,), NPCSummoningPurpose.BRING_PLAYER_SIM_TO_LOT)
else:
context = InteractionContext(pet_familiar, InteractionContext.SOURCE_SCRIPT, Priority.Critical, insert_strategy=QueueInsertStrategy.NEXT)
pet_familiar.push_super_affordance(FamiliarTracker.PET_FAMILIAR_SET_ACTIVE_AFFORDANCE, None, context)
except Exception as e:
self._on_familiar_summon_failure('Exception encountered when trying to create familiar. Deactivating familiar.', familiar_object=pet_familiar, exc=e)
if self._sim_buff_handle is None:
self._sim_buff_handle = self._owner.add_buff(self.ACTIVE_FAMILIAR_BUFF.buff_type, buff_reason=self.ACTIVE_FAMILIAR_BUFF.buff_reason)
return
familiar = services.object_manager().get(self._active_familiar_obj_id)
if familiar is None:
try:
familiar_obj_def = familiar_data.familiar_type.familiar_object
familiar = create_object(familiar_obj_def)
if familiar is None:
self._on_familiar_summon_failure('Failure to create familiar object. Deactivating familiar.')
return
resolver = SingleSimResolver(self._owner)
if not FamiliarTracker.FAMILIAR_PLACEMENT.try_place_object(familiar, resolver):
self._on_familiar_summon_failure('Failure to create familiar object. Deactivating familiar.', familiar_object=familiar, warn=True)
return
self._active_familiar_obj_id = familiar.id
except Exception as e:
self._on_familiar_summon_failure('Exception encountered when trying to create familiar. Deactivating familiar.', familiar_object=familiar, exc=e)
return
context = InteractionContext(sim, InteractionSource.SCRIPT, Priority.Critical, insert_strategy=QueueInsertStrategy.NEXT)
result = sim.push_super_affordance(familiar_data.familiar_type.follow_affordance, familiar, context)
if not result:
self._on_familiar_summon_failure('Failed to push familiar follow interaction. Deactivating Familiar.', familiar_object=familiar)
return
result.interaction.register_on_finishing_callback(self._on_familiar_follow_interaction_finished_prematurely)
if self._sim_buff_handle is None:
self._sim_buff_handle = self._owner.add_buff(self.ACTIVE_FAMILIAR_BUFF.buff_type, buff_reason=self.ACTIVE_FAMILIAR_BUFF.buff_reason)
def _spawn_sprinkler(self, fire):
zone_id = sims4.zone_utils.get_zone_id()
new_level = fire.location.level + 1
if not build_buy.has_floor_at_location(zone_id, fire.position, new_level):
return
sprinkler_object = system.create_object(self.SPRINKLER_HEAD_OBJECT_DEF)
sprinkler_location = fire.location.duplicate()
new_translation = sims4.math.Vector3(*fire.position)
height = terrain.get_lot_level_height(sprinkler_location.transform.translation.x, sprinkler_location.transform.translation.z, new_level, zone_id)
new_translation.y = height - self.SPRINKLER_HEAD_CEILING_OFFSET
sprinkler_location.transform = sims4.math.Transform(new_translation, sprinkler_location.transform.orientation)
sprinkler_object.set_location(location=sprinkler_location)
self._sprinkler_objects.add(sprinkler_object)
sprinkler_object.vfx = FireService.SPRINKLER_EFFECT(sprinkler_object)
sprinkler_object.vfx.start()
return sprinkler_object
def create_spawned_object(cls, inst, mother, definition, loc_type=ItemLocation.ON_LOT):
scale = GardeningTuning.SCALE_COMMODITY.default_value
child = None
try:
child = create_object(definition, loc_type=loc_type)
while not GardeningTuning.is_shoot(child) and mother.has_state(GardeningTuning.QUALITY_STATE_VALUE):
quality_state = mother.get_state(GardeningTuning.QUALITY_STATE_VALUE)
child.set_state(quality_state.state, quality_state)
scale *= GardeningTuning.SCALE_VARIANCE.random_float()
child.set_stat_value(GardeningTuning.SCALE_COMMODITY, scale)
except:
logger.exception('Failed to spawn.')
if child is not None:
child.destroy(source=mother, cause='Exception spawning child fruit.')
child = None
return child
def _try_create_in_household_inventory(self, sim_info, obj=None):
obj = create_object(
self._definition,
loc_type=ItemLocation.HOUSEHOLD_INVENTORY) if obj is None else obj
if obj is None:
logger.error(
'Trying to give an object reward to a Sim, {}, and the object created was None. Definition: {}',
sim_info, self._definition)
return (False, None)
obj.update_ownership(sim_info, make_sim_owner=False)
obj.set_post_bb_fixup_needed()
if not build_buy.move_object_to_household_inventory(obj):
logger.error(
'Failed to add reward definition object {} to household inventory.',
self._definition,
owner='rmccord')
def replace_for_age_up(self, interaction=None):
if interaction is not None:
interaction.set_target(None)
new_bassinet = create_object(self.definition)
new_bassinet.location = self.location
self.replacement_bassinet = new_bassinet
new_bassinet.set_sim_info(self.sim_info)
new_bassinet.copy_state_values(self,
state_list=Baby.BABY_AGE_UP.copy_states)
idle_state_value = Baby.BABY_AGE_UP.idle_state_value
new_bassinet.set_state(idle_state_value.state, idle_state_value)
if interaction is not None:
interaction.set_target(new_bassinet)
self.destroy(source=self.sim_info,
cause='Replacing bassinet for age up.')
return new_bassinet
def _create_automatic_objects(self, venue_tuning):
zone = services.current_zone()
for tag_pair in venue_tuning.automatic_objects:
try:
existing_objects = set(zone.object_manager.get_objects_with_tag_gen(tag_pair.tag))
while not existing_objects:
obj = create_object(tag_pair.default_value)
position = zone.lot.corners[1]
position += vector_normalize(zone.lot.position - position)
fgl_context = FindGoodLocationContext(starting_position=position, object_id=obj.id, ignored_object_ids=(obj.id,), search_flags=placement.FGLSearchFlagsDefault | placement.FGLSearchFlag.SHOULD_TEST_BUILDBUY, object_footprints=(obj.get_footprint(),))
(position, orientation) = find_good_location(fgl_context)
if position is not None:
obj.location = sims4.math.Location(sims4.math.Transform(position, orientation), routing.SurfaceIdentifier(zone.id, 0, routing.SURFACETYPE_WORLD))
else:
obj.destroy(source=zone, cause='Failed to place automatic object required by venue.')
except:
logger.error('Automatic object {} could not be created in venue {} (zone: {}).', obj_definition, venue_tuning, zone)
def debug_create_baby(actor_sim, position, gender, routing_surface=None):
baby = None
try:
actor_sim_info = actor_sim.sim_info
account = actor_sim.sim_info.account
sim_creator = SimCreator(
gender=gender,
age=Age.BABY,
first_name=SimSpawner.get_random_first_name(
account, gender == Gender.FEMALE),
last_name=SimSpawner.get_family_name_for_gender(
account, actor_sim.last_name, gender == Gender.FEMALE))
(sim_info_list, _) = SimSpawner.create_sim_infos(
(sim_creator, ),
household=actor_sim_info.household,
account=account,
zone_id=actor_sim_info.zone_id,
creation_source='cheat: debug_create_baby')
sim_info = sim_info_list[0]
baby_def = Baby.get_default_baby_def()
baby = create_object(baby_def, sim_info.sim_id)
baby.set_sim_info(sim_info)
fgl_context = placement.FindGoodLocationContext(
starting_position=position,
object_id=baby.id,
search_flags=placement.FGLSearchFlagsDefault,
object_footprints=(baby.get_footprint(), ))
(trans, orient) = placement.find_good_location(fgl_context)
if trans is not None:
baby.location = sims4.math.Location(
sims4.math.Transform(trans, orient), routing_surface)
client = services.client_manager().get_client_by_household_id(
sim_info.household_id)
while client is not None:
client.selectable_sims.add_selectable_sim_info(sim_info)
except Exception as e:
logger.exception('Create baby fail', e)
if actor_sim_info.household.sim_in_household(sim_info.sim_id):
actor_sim_info.household.remove_sim_info(sim_info)
client = services.client_manager().get_client_by_household_id(
sim_info.household_id)
if client is not None:
client.selectable_sims.remove_selectable_sim_info(sim_info)
while baby is not None:
baby.destroy(source=actor_sim, cause='Create baby fail')
def purchase_picker_response(inventory_target, mailman_purchase:bool=False, *def_ids_and_amounts, _connection=None):
total_price = 0
current_purchased = 0
objects_to_buy = []
definition_manager = services.definition_manager()
for (def_id, amount) in zip(def_ids_and_amounts[::2], def_ids_and_amounts[1::2]):
definition = definition_manager.get(def_id)
if definition is None:
sims4.commands.output('inventory.purchase_picker_response: Definition not found with id {}'.format(def_id), _connection)
return False
purchase_price = definition.price*amount
total_price += purchase_price
objects_to_buy.append((definition, amount))
client = services.client_manager().get(_connection)
if client is None:
sims4.commands.output('inventory.purchase_picker_response: No client found to make purchase.', _connection)
return False
household = client.household
if household.funds.money < total_price:
sims4.commands.output('inventory.purchase_picker_response: Insufficient funds for household to purchase items.', _connection)
return False
if mailman_purchase:
inventory = services.active_lot().get_hidden_inventory()
else:
inventory_owner = inventory_target.get_target()
inventory = inventory_owner.inventory_component
if inventory is None:
sims4.commands.output('inventory.purchase_picker_response: Inventory not found for items to be purchased into.', _connection)
return False
for (definition, amount) in objects_to_buy:
obj = create_object(definition)
if obj is None:
sims4.commands.output('inventory.purchase_picker_response: Failed to create object with definition {}.'.format(definition), _connection)
obj.set_stack_count(amount)
if not inventory.player_try_add_object(obj):
sims4.commands.output('inventory.purchase_picker_response: Failed to add object into inventory: {}'.format(obj), _connection)
obj.destroy(source=inventory, cause='inventory.purchase_picker_response: Failed to add object into inventory.')
obj.set_household_owner_id(household.id)
obj.try_post_bb_fixup(force_fixup=True, active_household_id=services.active_household_id())
purchase_price = definition.price*amount
current_purchased += purchase_price
household.funds.remove(current_purchased, Consts_pb2.TELEMETRY_OBJECT_BUY)
return True
def set_baby_sim_info_with_switch_id(bassinet, sim_info):
if bassinet.id != sim_info.sim_id:
new_bassinet = None
try:
save_data = bassinet.get_attribute_save_data()
empty_bassinet_def = bassinet.definition
baby_in_bassinet_def = Baby.get_corresponding_definition(empty_bassinet_def)
new_bassinet = create_object(baby_in_bassinet_def, obj_id=sim_info.sim_id)
new_bassinet.load(save_data)
new_bassinet.location = bassinet.location
except:
logger.error('{} fail to set sim_info {}', bassinet, sim_info)
if new_bassinet is not None:
new_bassinet.destroy(source=sim_info, cause='Failed to set sim_info on bassinet')
finally:
new_bassinet.set_sim_info(sim_info)
sim_info.supress_aging()
bassinet.hide(HiddenReasonFlag.REPLACEMENT)
return new_bassinet
def on_choice_selected(self, choice_tag, **kwargs):
mother = choice_tag
if mother is None:
return
father = self.target
transferable_states = {}
for state in self._combine_data.states_to_combine:
mother_state = mother.get_state(state)
father_state = father.get_state(state)
transferable_states[state] = [mother_state, father_state]
for combine_data in self._combine_data.combination_mapping:
while combine_data.father_state == father_state and combine_data.mother_state == mother_state:
transferable_states[state].append(combine_data.resulting_state)
if not transferable_states:
logger.error('CollectionPickerInteraction: {} and {} collectibles have no transferable states', mother, father, owner='camilogarcia')
return
states_to_transfer = []
for states in transferable_states.values():
states_to_transfer.append(sims4.random.random.choice(states))
target_match = len(states_to_transfer)
possible_outcomes = []
for collectable in self._collectible_data:
match = 0
for target_states in collectable.collectable_item.cls._components.state._tuned_values.states:
while target_states.default_value in states_to_transfer:
match += 1
while match == target_match:
possible_outcomes.append(collectable.collectable_item)
if not possible_outcomes:
logger.error('CollectionPickerInteraction: No possible result when combining {} and {}', mother, father, owner='camilogarcia')
return
definition_to_create = sims4.random.random.choice(possible_outcomes)
obj = create_object(definition_to_create)
if obj is None:
logger.error('CollectionPickerInteraction: Failed to create object when combining {} and {}', mother, father, owner='camilogarcia')
return
obj.update_ownership(self.sim.sim_info)
if not self.sim.inventory_component.player_try_add_object(obj):
obj.set_household_owner_id(services.active_household_id())
build_buy.move_object_to_household_inventory(obj, object_location_type=ObjectOriginLocation.SIM_INVENTORY)
self._push_continuation(obj)
def create_spawned_object(cls, inst, spawner_object, definition, loc_type=ItemLocation.ON_LOT):
obj = create_object(definition, loc_type=loc_type)
if obj is not None:
spawner_object.spawner_component._spawned_objects.add(obj)
return obj
def age_up_exit_behavior():
new_bassinet = create_object(Baby.get_corresponding_definition(middle_bassinet.definition))
new_bassinet.location = middle_bassinet.location
middle_bassinet.make_transient()
def create_object(self):
created_object = create_object(self.definition, init=self._setup_created_object, post_add=self._place_object)
if self._placement_failed:
created_object.destroy(source=self.interaction, cause='Failed to place object created by basic extra.')
return
return created_object
