def _apply_altitude(self, v, altitude, routing_surface=None): if altitude is None or altitude is KEEP_ALTITUDE: return v final_surface = routing_surface if routing_surface is not None else self.routing_surface if final_surface: level = final_surface.secondary_id else: level = 0 zone_id = services.current_zone_id() world_surface = routing.SurfaceIdentifier( zone_id, level, routing.SurfaceType.SURFACETYPE_WORLD) water_surface = routing.SurfaceIdentifier( zone_id, level, routing.SurfaceType.SURFACETYPE_POOL) object_surface = routing.SurfaceIdentifier( zone_id, level, routing.SurfaceType.SURFACETYPE_OBJECT) world_height = get_terrain_height(v.x, v.z, routing_surface=world_surface) water_height = get_terrain_height(v.x, v.z, routing_surface=water_surface) object_height = get_terrain_height(v.x, v.z, routing_surface=object_surface) h = max(world_height, water_height, object_height) if h == routing_constants.INVALID_TERRAIN_HEIGHT: h = get_terrain_center().y return sims4.math.Vector3(v.x, h + altitude, v.z)
def _on_quadtree_changed(self): quadtree = services.sim_quadtree() if quadtree is None: return zone = services.current_zone() pos = sims4.math.Vector2(0, 0) bounds = sims4.geometry.QtCircle(pos, 10000) all_sims_positions = quadtree.query( bounds=bounds, level=self.ALL_LEVELS, filter=placement.ItemType.SIM_POSITION, flags=sims4.geometry.ObjectQuadTreeQueryFlag.IGNORE_LEVEL) all_intended = quadtree.query( bounds=bounds, level=self.ALL_LEVELS, filter=placement.ItemType.SIM_INTENDED_POSITION, flags=sims4.geometry.ObjectQuadTreeQueryFlag.IGNORE_LEVEL) all_suppressors = quadtree.query( bounds=bounds, level=self.ALL_LEVELS, filter=placement.ItemType.ROUTE_GOAL_SUPPRESSOR, flags=sims4.geometry.ObjectQuadTreeQueryFlag.IGNORE_LEVEL) with Context(self.layer) as layer: layer.set_color(Color.GREEN) for o in all_sims_positions: height = terrain.get_lot_level_height( o[2].center.x, o[2].center.y, o[3], zone.id) + 0.1 pos = sims4.math.Vector3(o[2].center.x, height, o[2].center.y) layer.add_circle(pos, o[2].radius, altitude=KEEP_ALTITUDE) layer.set_color(Color.YELLOW) for o in all_intended: if isinstance(o[2], Polygon): routing_surface = routing.SurfaceIdentifier( zone.id, o[3], routing.SURFACETYPE_WORLD) layer.add_polygon(o[2], altitude=0.1, routing_surface=routing_surface) else: height = terrain.get_lot_level_height( o[2].center.x, o[2].center.y, o[3], zone.id) + 0.1 pos = sims4.math.Vector3(o[2].center.x, height, o[2].center.y) layer.add_circle(pos, o[2].radius, altitude=KEEP_ALTITUDE) layer.set_color(Color.RED) for o in all_suppressors: if isinstance(o[2], Polygon): routing_surface = routing.SurfaceIdentifier( zone.id, o[3], routing.SURFACETYPE_WORLD) layer.add_polygon(o[2], altitude=0.1, routing_surface=routing_surface) else: height = terrain.get_lot_level_height( o[2].center.x, o[2].center.y, o[3], zone.id) + 0.1 pos = sims4.math.Vector3(o[2].center.x, height, o[2].center.y) layer.add_circle(pos, o[2].radius, altitude=KEEP_ALTITUDE)
def _get_ladder_portal_locations(self, obj): additional_portal_flags = self._get_additional_portal_location_flags() blocked_alignment_flags = routing.get_blocked_ladder_portals( obj.id, obj.zone_id) if blocked_alignment_flags & PortalAlignment.get_bit_flag( self.portal_alignment): return [(None, None, None, None, PortalFlags.DEFAULT)] (top_level, bottom_level, _) = routing.get_ladder_levels_and_height(obj.id, obj.zone_id) down_start = self.climb_down_locations.location_start( obj, override_level=top_level) down_end = self.climb_down_locations.location_end( obj, override_level=bottom_level) down_start_position = down_start.position down_start_routing_surface = routing.SurfaceIdentifier( obj.zone_id, top_level, down_start.routing_surface.type) down_end_routing_surface = routing.SurfaceIdentifier( obj.zone_id, bottom_level, down_end.routing_surface.type) if self.climb_up_locations is not None: up_start = self.climb_up_locations.location_start( obj, override_level=bottom_level) up_end = self.climb_up_locations.location_end( obj, override_level=top_level) up_end_position = up_end.position up_start_routing_surface = routing.SurfaceIdentifier( obj.zone_id, bottom_level, up_start.routing_surface.type) up_end_routing_surface = routing.SurfaceIdentifier( obj.zone_id, top_level, up_end.routing_surface.type) locations = [(Location(up_start.position, orientation=up_start.orientation, routing_surface=up_start_routing_surface), Location(up_end_position, orientation=up_end.orientation, routing_surface=up_end_routing_surface), Location(down_start_position, orientation=down_start.orientation, routing_surface=down_start_routing_surface), Location(down_end.position, orientation=down_end.orientation, routing_surface=down_end_routing_surface), additional_portal_flags)] else: locations = [(Location(down_start_position, orientation=down_start.orientation, routing_surface=down_start_routing_surface), Location(down_end.position, orientation=down_end.orientation, routing_surface=down_end_routing_surface), None, None, additional_portal_flags)] return locations
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 create_starting_location(position=None, orientation=None, transform=None, routing_surface=None, location=None): starting_routing_location = None if location is None: if routing_surface is None: zone_id = services.current_zone_id() routing_surface = routing.SurfaceIdentifier( zone_id, 0, routing.SurfaceType.SURFACETYPE_WORLD) if transform is None: if position is None: logger.error( 'Trying to create a starting location for a FindGoodLocationContext but position is None. If position is going to remain None then either location or transform need to be passed in instead. -trevor' ) if orientation is None: orientation = sims4.math.angle_to_yaw_quaternion(0.0) starting_routing_location = routing.Location( position, orientation, routing_surface) else: starting_routing_location = routing.Location( transform.translation, transform.orientation, routing_surface) else: starting_routing_location = routing.Location( location.transform.translation, location.transform.orientation, location.routing_surface or location.world_routing_surface) return starting_routing_location
def test_placement(obj_id, x, y, z, rotation, level, parent_obj_id, parent_slot_hash, _connection=None): output = sims4.commands.Output(_connection) obj = objects.system.find_object(obj_id) if obj is None: output('Invalid object id') return False zone_id = sims4.zone_utils.get_zone_id() surface = routing.SurfaceIdentifier(zone_id, level, routing.SURFACETYPE_WORLD) position = sims4.math.Vector3(x, y, z) orientation = sims4.math.angle_to_yaw_quaternion(rotation) parent_obj = objects.system.find_object(parent_obj_id) transform = Transform(position, orientation) location = Location(transform, surface, parent_obj, parent_slot_hash, parent_slot_hash) (result, errors) = test_location_for_object(obj, location=location) if result: output('Placement is legal') else: output('Placement is NOT legal') if errors: for (code, msg) in errors: output(' {} ({})'.format(msg, code)) return result
def send_to_position(sim_info: SimInfo, location_position: Vector3, level: int) -> Union[EnqueueResult, None]: """send_to_position(sim_info, location_position, level) Send a Sim to the specified location. :param sim_info: The Sim to send. :type sim_info: SimInfo :param location_position: The position to send the sim to. :type location_position: Vector3 :param level: The level at which the position is. :type level: int :return: The result of sending the Sim to the specified location or None if they could not go there. :rtype: EnqueueResult """ from server_commands.sim_commands import _build_terrain_interaction_target_and_context, CommandTuning if location_position is None: return None sim = CommonSimUtils.get_sim_instance(sim_info) # noinspection PyUnresolvedReferences pos = sims4.math.Vector3(location_position.x, location_position.y, location_position.z) routing_surface = routing.SurfaceIdentifier( CommonLocationUtils.get_current_zone_id(), level, routing.SurfaceType.SURFACETYPE_WORLD) (target, context) = _build_terrain_interaction_target_and_context( sim, pos, routing_surface, PickType.PICK_TERRAIN, objects.terrain.TerrainPoint) return sim.push_super_affordance( CommandTuning.TERRAIN_GOHERE_AFFORDANCE, target, context)
def __init__(self, definition, **kwargs): self._ui_metadata_stack = [] self._ui_metadata_handles = {} self._ui_metadata_cache = {} super().__init__(definition, **kwargs) if definition is not None: self.apply_definition(definition, **kwargs) self.primitives = distributor.ops.DistributionSet(self) self._location = sims4.math.Location( sims4.math.Transform(), routing.SurfaceIdentifier(sims4.zone_utils.get_zone_id(), 0, routing.SURFACETYPE_WORLD)) self._children = WeakSet() self._occupied_slot_dict = {} self._scale = 1 self._parent_type = ObjectParentType.PARENT_NONE self._parent_location = 0 self._build_buy_lockout = False self._build_buy_lockout_alarm_handler = None self._tint = None self._opacity = None self._censor_state = None self._geometry_state = None self._visibility = None self._material_state = None self._reference_arb = None self._audio_effects = {} self._video_playlist = None self._painting_state = None self._current_value = definition.price self._needs_post_bb_fixup = False self._needs_depreciation = False self._fade_out_alarm_handle = None
def validate_spawn_points(self): if not self._spawner_data and not self._dynamic_spawn_points: return dest_handles = set() lot_center = self.lot.center lot_corners = self.lot.corners routing_surface = routing.SurfaceIdentifier(self.id, 0, routing.SURFACETYPE_WORLD) for corner in lot_corners: diff = lot_center - corner if diff.magnitude_squared() != 0: towards_center_vec = sims4.math.vector_normalize(lot_center - corner) * 0.1 else: towards_center_vec = sims4.math.Vector3.ZERO() new_corner = corner + towards_center_vec location = routing.Location( new_corner, sims4.math.Quaternion.IDENTITY(), routing_surface) dest_handles.add(routing.connectivity.Handle(location)) for spawn_point in self.spawn_points_gen(): spawn_point.reset_valid_slots() routing_context = routing.PathPlanContext() routing_context.set_key_mask(routing.FOOTPRINT_KEY_ON_LOT | routing.FOOTPRINT_KEY_OFF_LOT) if spawn_point.footprint_id is not None: routing_context.ignore_footprint_contour( spawn_point.footprint_id) spawn_point.validate_slots(dest_handles, routing_context)
def get_center_of_mass_constraint(self): if not self: logger.warn('No Sims in ensemble when trying to construct constraint.') return ANYWHERE (level, position) = self.calculate_level_and_center_of_mass() routing_surface = routing.SurfaceIdentifier(services.current_zone_id(), level, routing.SurfaceType.SURFACETYPE_WORLD) return Circle(position, sqrt(self.max_ensemble_radius), routing_surface)
def routing_location(self): lot = services.active_lot() return routing.Location(lot.position, orientation=lot.orientation, routing_surface=routing.SurfaceIdentifier( services.current_zone().id, 0, routing.SurfaceType.SURFACETYPE_WORLD))
def _create_floor_feature_constraint_set(cls, inst, sim): inst_or_cls = inst if inst is not None else cls floor_feature_contraints = [] floor_features_and_surfaces = [] zone_id = services.current_zone_id() floor_features = build_buy.list_floor_features(inst_or_cls.terrain_feature) if floor_features is None: return Nowhere('No found floor features.') radius_object = None if inst_or_cls.radius_filter is not None: radius_object = inst_or_cls.get_participant(inst_or_cls.radius_filter.radius_actor) if inst_or_cls.radius_filter is not None and radius_object is None: return Nowhere('Radius filter is enabled but the radius actor has a None value.') for floor_feature in floor_features: if inst_or_cls.indoors_only and build_buy.is_location_natural_ground(floor_feature[0], floor_feature[1]): continue routing_surface = routing.SurfaceIdentifier(zone_id, floor_feature[1], routing.SurfaceType.SURFACETYPE_WORLD) floor_feature_location = floor_feature[0] if inst_or_cls.radius_filter is not None: if (radius_object.position - floor_feature_location).magnitude_squared() <= inst_or_cls.radius_filter.radius: floor_features_and_surfaces.append((floor_feature_location, routing_surface)) floor_features_and_surfaces.append((floor_feature_location, routing_surface)) else: floor_features_and_surfaces.append((floor_feature_location, routing_surface)) if floor_features_and_surfaces: for floor_feature_and_surface in floor_features_and_surfaces: circle_constraint = inst_or_cls.routing_circle_constraint.create_constraint(sim, None, target_position=floor_feature_and_surface[0], routing_surface=floor_feature_and_surface[1]) facing_constraint = inst_or_cls.routing_facing_constraint.create_constraint(sim, None, target_position=floor_feature_and_surface[0], routing_surface=floor_feature_and_surface[1]) constraint = circle_constraint.intersect(facing_constraint) floor_feature_contraints.append(constraint) return create_constraint_set(floor_feature_contraints) return Nowhere('With radius filter enabled, no found floor features are within range.')
def provided_routing_surface(self): if self._provided_surface is UNSET: self._provided_surface = None if self.routing_surface is not None: if self.has_component(FOOTPRINT_COMPONENT): if placement.has_object_surface_footprint(self.get_footprint()): self._provided_surface = routing.SurfaceIdentifier(services.current_zone_id(), self.routing_surface.secondary_id, routing.SurfaceType.SURFACETYPE_OBJECT) return self._provided_surface
def routing_debug_generate_routing_goals_from_geometry( *args, obj: OptionalTargetParam = None, _connection=None): output = sims4.commands.Output(_connection) obj = get_optional_target(obj, _connection=_connection) if obj is None: return False routing_component = obj.get_component(ROUTING_COMPONENT) if routing_component is None: return False total_string = ''.join(args) polygon_strs = find_substring_in_repr(total_string, POLYGON_STR, POLYGON_END_PARAM) if not polygon_strs: output('No valid polygons. must start with {} and end with {}'.format( POLYGON_STR, POLYGON_END_PARAM)) return constraints = [] routing_surface = routing.SurfaceIdentifier( services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_OBJECT) for poly_str in polygon_strs: point_list = extract_floats(poly_str) if not point_list or len(point_list) % 2 != 0: output('Point list is not valid length. Too few or one too many.') return vertices = [] for index in range(0, len(point_list), 2): vertices.append( sims4.math.Vector3(point_list[index], 0.0, point_list[index + 1])) polygon = sims4.geometry.Polygon(vertices) geometry = RestrictedPolygon(polygon, []) constraints.append( Constraint(geometry=geometry, routing_surface=routing_surface)) constraint_set = create_constraint_set(constraints) if not postures.posture_graph.enable_debug_goals_visualization: sims4.commands.execute('debugvis.goals.enable', _connection) handles = constraint_set.get_connectivity_handles(obj) handles_str = 'Handles: {}'.format(len(handles)) sims4.commands.output(handles_str, _connection) all_goals = [] for handle in handles: goal_list = handle.get_goals() goals_str = '\tGoals: {}'.format(len(goal_list)) sims4.commands.output(goals_str, _connection) all_goals.extend(goal_list) if postures.posture_graph.enable_debug_goals_visualization: for constraint in constraints: with debugvis.Context( 'goal_scoring', routing_surface=constraint.routing_surface) as layer: for polygon in constraint.geometry.polygon: layer.add_polygon( polygon, routing_surface=constraint.routing_surface) for goal in all_goals: position = goal.location.transform.translation layer.add_point(position, routing_surface=constraint.routing_surface)
def has_choices(target_id:int=None, pick_type=PickType.PICK_TERRAIN, x:float=0.0, y:float=0.0, z:float=0.0, lot_id:int=0, level:int=0, control:int=0, alt:int=0, shift:int=0, reference_id:int=0, _connection=None): if target_id is None: return zone = services.current_zone() client = zone.client_manager.get(_connection) if client is None: return sim = _active_sim(client) shift_held = bool(shift) if shift_held: if client.household.cheats_enabled or __debug__: _send_interactable_message(client, target_id, True) else: _send_interactable_message(client, target_id, False) return context = None pick_type = int(pick_type) pick_pos = sims4.math.Vector3(x, y, z) routing_surface = routing.SurfaceIdentifier(zone.id, level, routing.SURFACETYPE_WORLD) target = zone.find_object(target_id) if pick_type in PICK_USE_TERRAIN_OBJECT or lot_id and lot_id != services.active_lot().lot_id: location = sims4.math.Location(sims4.math.Transform(pick_pos), routing_surface) target = objects.terrain.TerrainPoint(location) elif pick_type == PickType.PICK_SIM and target is None: target = sim elif pick_type == PickType.PICK_OBJECT and target is not None and target.object_routing_surface is not None: pick_type = int(pick_type) routing_surface = target.object_routing_surface location = sims4.math.Location(sims4.math.Transform(pick_pos), routing_surface) target = objects.terrain.TerrainPoint(location) is_interactable = False if target is not None: pick = PickInfo(pick_type, target, pick_pos, routing_surface, lot_id, bool(alt), bool(control)) context = client.create_interaction_context(sim, pick=pick) for aop in target.potential_interactions(context): result = ChoiceMenu.is_valid_aop(aop, context, False, user_pick_target=target) if not result and not result.tooltip: pass is_interactable = aop.affordance.allow_user_directed if not is_interactable: is_interactable = aop.affordance.has_pie_menu_sub_interactions(aop.target, context, **aop.interaction_parameters) while is_interactable: break if not is_interactable and sim is not None: while True: for si in sim.si_state: potential_targets = si.get_potential_mixer_targets() while True: for potential_target in potential_targets: if target is potential_target: break while potential_target.is_part and potential_target.part_owner is target: break while autonomy.content_sets.any_content_set_available(sim, si.super_affordance, si, context, potential_targets=(target,), include_failed_aops_with_tooltip=True): is_interactable = True break _send_interactable_message(client, target_id, is_interactable, True)
def __init__(self, lot_id, zone_id, spawn_point_id=None, routing_surface=None): self.lot_id = lot_id if routing_surface is None: routing_surface = routing.SurfaceIdentifier(zone_id, 0, routing.SurfaceType.SURFACETYPE_WORLD) self._routing_surface = routing_surface if spawn_point_id is None: self._spawn_point_id = id_generator.generate_object_id() else: self._spawn_point_id = spawn_point_id self.attractor_point_ids = set()
def __init__(self, lot_id, zone_id, routing_surface=None): self.center = None self.lot_id = lot_id self._tags = set() if routing_surface is None: routing_surface = routing.SurfaceIdentifier( zone_id, 0, routing.SURFACETYPE_WORLD) self._routing_surface = routing_surface self._valid_slots = 0 self._on_spawn_points_changed = CallableList()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if self._target is None: self._start_constraint = Nowhere( 'No target for _WaypointGeneratorPacing') self._los_reference_point = None return self._los_reference_point = self._target.position if self._target.is_terrain: self._los_reference_point = None water_constraint = self.get_water_constraint( self.constraint_parameters.min_water_depth, self.constraint_parameters.max_water_depth) if self.outside_only: self._routing_surface = routing.SurfaceIdentifier( services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_WORLD) starting_location = Location(position=self._target.position, routing_surface=self._routing_surface) search_flags = FGLSearchFlagsDefaultForSim | FGLSearchFlag.STAY_OUTSIDE fgl_context = placement.FindGoodLocationContext( starting_location, routing_context=self._context.sim.routing_context, additional_avoid_sim_radius=routing.get_default_agent_radius(), max_results=1, max_steps=10, search_flags=search_flags, min_water_depth=water_constraint.get_min_water_depth(), max_water_depth=water_constraint.get_max_water_depth()) (trans, _) = placement.find_good_location(fgl_context) if trans is not None: geometry = sims4.geometry.RestrictedPolygon( sims4.geometry.CompoundPolygon( sims4.geometry.Polygon((trans, ))), ()) self._start_constraint = SmallAreaConstraint( geometry=geometry, debug_name='WaypointPacingStartingConstraint', routing_surface=self._routing_surface, min_water_depth=water_constraint.get_min_water_depth(), max_water_depth=water_constraint.get_max_water_depth()) else: self._start_constraint = Nowhere( 'WaypointGeneratorPacing requires outside, but we failed to find a good location.' ) else: self._start_constraint = Circle( self._target.position, self.constraint_parameters.object_constraint_radius, routing_surface=self._routing_surface, los_reference_point=self._los_reference_point, min_water_depth=water_constraint.get_min_water_depth(), max_water_depth=water_constraint.get_max_water_depth())
def snap_to_good_location_on_floor(target, *args, starting_transform=None, starting_routing_surface=None, **kwargs): target.visibility = VisibilityState(True, True, True) parent = target.get_parenting_root() if starting_transform is None: starting_transform = parent.transform starting_transform = sims4.math.Transform( parent.position + parent.forward * parent.object_radius, starting_transform.orientation) if starting_routing_surface is None: starting_routing_surface = parent.routing_surface translation = None orientation = None is_lot_clearing = services.current_zone().is_active_lot_clearing if not is_lot_clearing: (translation, orientation) = CarryingObject.get_good_location_on_floor( target, *args, starting_transform=starting_transform, starting_routing_surface=starting_routing_surface, **kwargs) if translation is not None: target.clear_parent(sims4.math.Transform(translation, orientation), starting_routing_surface) return True logger.debug( 'snap_to_good_location_on_floor could not find good location for {}.', target) clear_transform = starting_transform clear_routing_surface = starting_routing_surface if not (is_lot_clearing or not build_buy.has_floor_at_location( starting_transform.translation, starting_routing_surface.secondary_id)): clear_routing_surface = routing.SurfaceIdentifier( services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_WORLD) ground_position = sims4.math.Vector3( starting_transform.translation.x, starting_transform.translation.y, starting_transform.translation.z) ground_position.y = services.terrain_service.terrain_object( ).get_routing_surface_height_at(starting_transform.translation.x, starting_transform.translation.z, clear_routing_surface) clear_transform = sims4.math.Transform( ground_position, starting_transform.orientation) target.clear_parent(clear_transform, clear_routing_surface) return False
def create_object(def_id, x: float = 0.0, y: float = 0.0, z: float = 0.0, level: int = 0, _connection=None): obj = objects.system.create_object(def_id) if obj is not None: routing_surface = routing.SurfaceIdentifier( sims4.zone_utils.get_zone_id(), level, routing.SURFACETYPE_WORLD) obj.move_to(translation=sims4.math.Vector3(x, y, z), routing_surface=routing_surface) return obj
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) sim = self._context.sim self._routing_surface = routing.SurfaceIdentifier( self._routing_surface.primary_id, self._routing_surface.secondary_id, routing.SurfaceType.SURFACETYPE_POOL) position = self._target.position if self._target is not None else sim.position level = self._routing_surface.secondary_id self._start_constraint = None self._master_depth_constraint = None self._waypoint_constraints = [] self.keep_away_constraint = None self._location_is_pool = build_buy.is_location_pool(position, level) if self._location_is_pool: pool_block_id = build_buy.get_block_id(sim.zone_id, position, level - 1) pool = pool_utils.get_pool_by_block_id(pool_block_id) if pool is not None: pool_edge_constraints = pool.get_edge_constraint( constraint_width=self.constraint_width, inward_dir=True, return_constraint_list=True) pool_edge_constraints = [ constraint.generate_geometry_only_constraint() for constraint in pool_edge_constraints ] if self.keep_away_from_edges is not None: bb_polys = build_buy.get_pool_polys( pool_block_id, level - 1) if len(bb_polys) > 0: bb_poly = bb_polys[0] _WaypointGeneratorPool._push_poly_inward( bb_poly, self.keep_away_from_edges) bb_poly.reverse() keep_away_geom = sims4.geometry.RestrictedPolygon( sims4.geometry.Polygon(bb_poly), ()) self.keep_away_constraint = Constraint( routing_surface=pool.provided_routing_surface, geometry=keep_away_geom) else: logger.error( f'Pool Waypoint Generator: Pool polygon data unexpectedly empty while ${sim} was routing on a pool with id ${pool_block_id}.', owner='jmorrow') for i in range(len(pool_edge_constraints)): pool_edge_constraints[i] = pool_edge_constraints[ i].intersect(self.keep_away_constraint) self._start_constraint = create_constraint_set( pool_edge_constraints) self._waypoint_constraints = pool_edge_constraints
def create_multiple_objects(number, *obj_ids, _connection=None): manager = services.object_manager() sim = get_optional_target(None, _connection) search_flags = placement.FGLSearchFlagsDefault | placement.FGLSearchFlag.SHOULD_TEST_BUILDBUY if sim is not None: starting_position = sim.position routing_surface = sim.routing_surface else: lot = services.active_lot() starting_position = lot.position routing_surface = routing.SurfaceIdentifier(services.current_zone().id, 0, routing.SURFACETYPE_WORLD) with postures.posture_graph.supress_posture_graph_build(): for obj_id in obj_ids: obj_id = int(obj_id) original_obj = None if obj_id in manager: original_obj = manager.get(obj_id) if original_obj is None: return obj_definition_id = original_obj.definition.id created_obj_count = number while created_obj_count > 0: if original_obj.crafting_component is not None: obj = DebugCreateCraftableInteraction.create_craftable( original_obj.crafting_component._crafting_process. recipe, sim) else: obj = objects.system.create_object(obj_definition_id) if obj is not None: fgl_context = placement.FindGoodLocationContext( starting_position=starting_position, object_id=obj.id, search_flags=search_flags, object_footprints=(obj.get_footprint(), )) (position, orientation) = placement.find_good_location(fgl_context) if position is not None and orientation is not None: obj.move_to(translation=position, orientation=orientation, routing_surface=routing_surface) else: obj.destroy( source=obj, cause= 'Failed to find good location for create_multiple_objects' ) created_obj_count -= 1
def footprint_intersection_check(resource_key, offset, orientation, circles, routing_surface=None): raise RuntimeError( '[bhill] This function is believed to be dead code and is scheduled for pruning. If this exception has been raised, the code is not dead and this exception should be removed.' ) if routing_surface is None: zone_id = sims4.zone_utils.get_zone_id() routing_surface = routing.SurfaceIdentifier(zone_id, 0, routing.SURFACETYPE_WORLD) return _placement.test_footprint_intersection(resource_key, offset, orientation, routing_surface, circles)
def _on_quadtree_changed(self): quadtree = services.sim_quadtree() if quadtree is None: return bounds = QtCircle(Vector2(0, 0), 10000) with Context(self.layer) as layer: filter_visualizers = ((placement.ItemType.SIM_POSITION, Color.GREEN), (placement.ItemType.SIM_INTENDED_POSITION, Color.YELLOW), (placement.ItemType.ROUTE_GOAL_SUPPRESSOR, Color.RED), (placement.ItemType.ROUTABLE_OBJECT_SURFACE, Color.CYAN)) for (quadtree_filter, color) in filter_visualizers: layer.set_color(color) for o in quadtree.query(bounds=bounds, surface_id=routing.SurfaceIdentifier(0, 0, 0), filter=quadtree_filter, flags=ObjectQuadTreeQueryFlag.IGNORE_SURFACE): if isinstance(o[2], Polygon): layer.add_polygon(o[2], altitude=0.1, routing_surface=o[3]) else: height = terrain.get_lot_level_height(o[2].center.x, o[2].center.y, o[3].secondary_id, services.current_zone_id()) + 0.1 layer.add_circle(sims4.math.Vector3(o[2].center.x, height, o[2].center.y), o[2].radius, altitude=KEEP_ALTITUDE)
def __init__(self, interaction, participant_type, distance_to_participant, tag_set, lot_id, zone_id, allow_spawning_on_non_world_routing_surfaces): self._interaction = interaction self._participant_type = participant_type self._distance_to_participant = distance_to_participant self._tags = tag_set self._allow_spawning_on_non_world_routing_surfaces = allow_spawning_on_non_world_routing_surfaces self._routing_surface_override = None routing_surface = None participant = self._get_participant() if participant is not None: if participant.routing_surface.type == routing.SurfaceType.SURFACETYPE_WORLD or allow_spawning_on_non_world_routing_surfaces: routing_surface = participant.routing_surface else: level = participant.routing_surface.secondary_id routing_surface = routing.SurfaceIdentifier(services.current_zone().id, level, routing.SurfaceType.SURFACETYPE_WORLD) super().__init__(lot_id, zone_id, routing_surface=routing_surface)
def __init__(self, guid, template=None, debug_name=None, parent=None, species=None): self.id = guid self.template = template if species is not None: self._species = species elif template is not None: self._species = template.species else: self._species = Species.HUMAN self.debug_name = debug_name self.parent = parent self.asm_auto_exit = AsmAutoExitInfo() self.routing_context = PathPlanContext() zone_id = services.current_zone_id() routing_surface = routing.SurfaceIdentifier(zone_id or 0, 0, routing.SurfaceType.SURFACETYPE_WORLD) self.routing_location = routing.Location(sims4.math.Vector3.ZERO(), sims4.math.Quaternion.IDENTITY(), routing_surface)
def _get_door_connections_from_arrival(self, doors, is_apartment=False): zone = services.current_zone() source_point = self._get_arrival_point() source_handles = set() source_handle = Handle( source_point, routing.SurfaceIdentifier(zone.id, 0, routing.SurfaceType.SURFACETYPE_WORLD)) source_handles.add(source_handle) routing_context = routing.PathPlanContext() for door in doors: for portal_handle in door.get_portal_pairs(): routing_context.lock_portal(portal_handle.there) routing_context.lock_portal(portal_handle.back) routing_context.set_key_mask(routing.FOOTPRINT_KEY_ON_LOT | routing.FOOTPRINT_KEY_OFF_LOT) if is_apartment: routing_context.set_portal_key_mask( DoorService.FRONT_DOOR_ALLOWED_PORTAL_FLAGS | DoorService.FRONT_DOOR_ALLOWED_APARTMENT_PORTAL_FLAGS) else: routing_context.set_portal_key_mask( DoorService.FRONT_DOOR_ALLOWED_PORTAL_FLAGS) dest_handles = set() for door in doors: (front_position, back_position) = door.get_door_positions() if not front_position is None: if back_position is None: continue dest_handles.add( DoorConnectivityHandle(front_position, door.routing_surface, door=door, is_front=True)) dest_handles.add( DoorConnectivityHandle(back_position, door.routing_surface, door=door, is_front=False)) connections = () if dest_handles: connections = routing.estimate_path_batch( source_handles, dest_handles, routing_context=routing_context) if connections is None: connections = () return connections
def __init__(self, definition, **kwargs): super().__init__(definition, **kwargs) if definition is not None: self.apply_definition(definition, **kwargs) self._ui_metadata_stack = None self._ui_metadata_handles = None self._ui_metadata_cache = None self.primitives = distributor.ops.DistributionSet(self) zone_id = services.current_zone_id() self._location = sims4.math.Location( sims4.math.Transform(), routing.SurfaceIdentifier(zone_id, 0, routing.SurfaceType.SURFACETYPE_WORLD)) self._children_objects = None self._scale = 1 self._parent_type = ObjectParentType.PARENT_NONE self._parent_location = 0 self._build_buy_lockout = False self._build_buy_lockout_alarm_handler = None self._tint = None self._opacity = None self._censor_state = None self._geometry_state = None self._geometry_state_overrides = None self._standin_model = None self._visibility = None self._visibility_flags = None self._material_state = None self._reference_arb = None self._audio_effects = None self._video_playlist = None self._painting_state = None self.custom_name = None self.custom_description = None self._multicolor = None self._display_number = None self._awareness_scores = None self._scratched = False self._base_value = definition.price self._needs_post_bb_fixup = False self._needs_depreciation = False self._swapping_to_parent = None self._swapping_from_parent = None self._on_children_changed = None self.allow_opacity_change = True self._wind_speed_effect = None
def get_lot_corners_constraint_set(self): lot_center = self.lot.center lot_corners = services.current_zone().lot.corners routing_surface = routing.SurfaceIdentifier( services.current_zone().id, 0, routing.SURFACETYPE_WORLD) constraint_list = [] for corner in lot_corners: diff = lot_center - corner if diff.magnitude_squared() != 0: towards_center_vec = sims4.math.vector_normalize(lot_center - corner) * 0.1 else: towards_center_vec = sims4.math.Vector3.ZERO() new_corner = corner + towards_center_vec constraint_list.append(interactions.constraints.Position( new_corner, routing_surface=routing_surface)) return create_constraint_set(constraint_list)
def polygon_intersection(*args, _connection=None): output = sims4.commands.Output(_connection) total_string = ''.join(args) polygon_strs = find_substring_in_repr(total_string, POLYGON_STR, POLYGON_END_PARAM) if not polygon_strs: output('No valid polygons. must start with {} and end with {}'.format( POLYGON_STR, POLYGON_END_PARAM)) return constraints = [] for poly_str in polygon_strs: point_list = extract_floats(poly_str) if not point_list or len(point_list) % 2 != 0: output('Point list is not valid length. Too few or one too many.') return vertices = [] for index in range(0, len(point_list), 2): vertices.append( sims4.math.Vector3(point_list[index], 0.0, point_list[index + 1])) polygon = sims4.geometry.Polygon(vertices) geometry = sims4.geometry.RestrictedPolygon(polygon, []) constraint = Constraint(geometry=geometry, routing_surface=routing.SurfaceIdentifier( services.current_zone_id(), 0, routing.SurfaceType.SURFACETYPE_WORLD)) constraints.append(constraint) intersection = ANYWHERE for constraint in constraints: new_intersection = intersection.intersect(constraint) if not new_intersection.valid: output( 'Constraint intersection failed. Drawing incompatible geometry. {}' .format(new_intersection)) if intersection.geometry is not None: draw_geometry_in_string(str(intersection.geometry), _connection=_connection) draw_geometry_in_string(str(constraint.geometry), _connection=_connection) return intersection = new_intersection if intersection.valid: draw_geometry_in_string(str(intersection.geometry), _connection=_connection) output('Intersection valid. Drawing Polygon.')