def _drop_carried_object(self):
if self.target is None:
return
if self.target.is_sim:
return
if self.target_is_transient or self.target.parent is not self.sim:
return
if self.snap_to_good_location_on_floor(self.target):
return
if self.sim.household.id is self.target.get_household_owner_id(
) and self.sim.inventory_component.player_try_add_object(self.target):
return
placement_flags = build_buy.get_object_placement_flags(
self.target.definition.id)
if placement_flags & build_buy.PlacementFlags.NON_DELETEABLE and placement_flags & build_buy.PlacementFlags.NON_INVENTORYABLE:
logger.error(
"Failed to find a location to place {}, which cannot be deleted or moved to the household inventory. Object will be placed at the Sim's feet, but this is unsafe and will probably result in the object being destroyed on load.",
self.target,
owner='tastle')
return
if placement_flags & build_buy.PlacementFlags.NON_INVENTORYABLE:
self.target.destroy(
source=self.sim,
cause=
'Failed to find location to drop non inventoryable object.')
elif not build_buy.move_object_to_household_inventory(
self.target,
failure_flags=HouseholdInventoryFlags.DESTROY_OBJECT):
logger.warn(
'Failed to drop carried object {}, which cannot be placed in the household inventory. This object will be destroyed.',
self.target,
owner='rmccord')
def _drop_carried_object(self):
if self.target is None:
return
if self.target_is_transient or self.target.parent is not self.sim:
return
if self.snap_to_good_location_on_floor(self.target):
return
if self.sim.household.id is self.target.get_household_owner_id() and self.sim.inventory_component.player_try_add_object(self.target):
return
placement_flags = build_buy.get_object_placement_flags(self.target.definition.id)
if placement_flags & build_buy.PlacementFlags.NON_DELETEABLE and placement_flags & build_buy.PlacementFlags.NON_INVENTORYABLE:
logger.error("Failed to find a location to place {}, which cannot be deleted or moved to the household inventory. Object will be placed at the Sim's feet, but this is unsafe and will probably result in the object being destroyed on load.", self.target, owner='tastle')
return
if placement_flags & build_buy.PlacementFlags.NON_INVENTORYABLE:
self.target.destroy(source=self.sim, cause='Failed to find location to drop non inventoryable object.')
else:
build_buy.move_object_to_household_inventory(self.target)
def start_objects_burning(self, fire_object):
location = sims4.math.Vector2(fire_object.position.x, fire_object.position.z)
fire_level = fire_object.location.level
result = self._query_quadtree_for_flammable_object(location, level=fire_level)
if result is not None:
for obj in result:
if obj.location.level != fire_level:
pass
placement_flags = build_buy.get_object_placement_flags(obj.definition.id)
if placement_flags & build_buy.PlacementFlags.CEILING and not placement_flags & build_buy.PlacementFlags.WALL_GRAPH_PLACEMENT:
pass
logger.debug('Fire object ({}) overlaps with {}\n', fire_object, obj)
if self._burning_objects is None:
self._burning_objects = {}
if fire_object not in self._burning_objects:
self._burning_objects[fire_object] = []
self._burning_objects[fire_object].append(obj)
self.set_object_burning(obj)
fire_object.raycast_context_dirty = True
result = self._query_quadtree_for_sim(location, level=fire_level, filter_type=placement.ItemType.SIM_POSITION)
if result is not None:
for (sim, _, _, _) in result:
while not self.sim_is_on_fire(sim):
self._burn_sim(sim, fire_object)
def wall_or_fence_placement(self):
placement_flags = build_buy.get_object_placement_flags(
self.definition.id)
if placement_flags & build_buy.PlacementFlags.WALL_GRAPH_PLACEMENT:
return True
return False
def save(self,
object_list=None,
zone_data=None,
open_street_data=None,
store_travel_group_placed_objects=False,
**kwargs):
if object_list is None:
return
open_street_objects = file_serialization.ObjectList()
total_beds = 0
double_bed_exist = False
kid_bed_exist = False
alternative_sleeping_spots = 0
university_roommate_beds = 0
if store_travel_group_placed_objects:
objects_to_save_for_clean_up = []
roommate_bed_tags = set()
roommate_service = services.get_roommate_service()
if roommate_service is not None:
roommate_bed_tags = roommate_service.BED_TAGS
for game_object in self._objects.values():
if self._should_save_object_on_lot(game_object):
save_result = ObjectManager.save_game_object(
game_object, object_list, open_street_objects)
if not save_result:
continue
if zone_data is None:
continue
if store_travel_group_placed_objects and save_result.owner_id != 0:
placement_flags = build_buy.get_object_placement_flags(
game_object.definition.id)
if build_buy.PlacementFlags.NON_INVENTORYABLE not in placement_flags:
objects_to_save_for_clean_up.append(save_result)
if not game_object.definition.has_build_buy_tag(
*self._all_bed_tags):
continue
if game_object.definition.has_build_buy_tag(
*self.BED_TAGS.double_beds):
double_bed_exist = True
total_beds += 1
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.kid_beds):
total_beds += 1
kid_bed_exist = True
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.other_sleeping_spots):
alternative_sleeping_spots += 1
elif game_object.definition.has_build_buy_tag(
*self.BED_TAGS.beds):
total_beds += 1
if len(roommate_bed_tags) > 0:
if game_object.definition.has_build_buy_tag(
*roommate_bed_tags):
university_roommate_beds += 1
if open_street_data is not None:
open_street_data.objects = open_street_objects
if zone_data is not None:
bed_info_data = gameplay_serialization.ZoneBedInfoData()
bed_info_data.num_beds = total_beds
bed_info_data.double_bed_exist = double_bed_exist
bed_info_data.kid_bed_exist = kid_bed_exist
bed_info_data.alternative_sleeping_spots = alternative_sleeping_spots
if roommate_service is not None:
household_and_roommate_cap = roommate_service.HOUSEHOLD_AND_ROOMMATE_CAP
bed_info_data.university_roommate_beds = min(
household_and_roommate_cap, university_roommate_beds)
zone_data.gameplay_zone_data.bed_info_data = bed_info_data
if store_travel_group_placed_objects:
current_zone = services.current_zone()
save_game_protocol_buffer = services.get_persistence_service(
).get_save_game_data_proto()
self._clear_clean_up_data_for_zone(current_zone,
save_game_protocol_buffer)
self._save_clean_up_destination_data(
current_zone, objects_to_save_for_clean_up,
save_game_protocol_buffer)
lot = services.current_zone().lot
for (inventory_type, inventory) in lot.get_all_object_inventories_gen(
shared_only=True):
for game_object in inventory:
game_object.save_object(object_list.objects,
ItemLocation.OBJECT_INVENTORY,
inventory_type)
def _has_placement_flag(self, placement_flag):
placement_flags = build_buy.get_object_placement_flags(self.definition.id)
if placement_flags & placement_flag:
return True
return False
def _fixup_pool_surface(self):
if (self.item_location == ItemLocation.FROM_WORLD_FILE or self.item_location == ItemLocation.FROM_CONDITIONAL_LAYER) and (self.routing_surface.type != SurfaceType.SURFACETYPE_POOL and build_buy.PlacementFlags.REQUIRES_WATER_SURFACE & build_buy.get_object_placement_flags(self.definition.id)) and get_water_depth_at_location(self.location) > 0:
routing_surface = self.routing_surface
self.set_location(self.location.clone(routing_surface=SurfaceIdentifier(routing_surface.primary_id, routing_surface.secondary_id, SurfaceType.SURFACETYPE_POOL)))
def _create_mailbox_handle(self, mailbox):
position = mailbox.position
if PlacementFlags.EDGE_AGAINST_WALL & get_object_placement_flags(
mailbox.definition.id):
position = mailbox.position + mailbox.forward * WALL_OBJECT_POSITION_PADDING
return ObjectConnectivityHandle(mailbox, position)