def get_orientation(sim_info: SimInfo) -> CommonQuaternion: """get_orientation(sim_info) Retrieve the orientation of a Sim. :param sim_info: An instance of a Sim. :type sim_info: SimInfo :return: The orientation of the Sim. :rtype: CommonQuaternion """ if sim_info is None: return CommonQuaternion.empty() sim = CommonSimUtils.get_sim_instance(sim_info) if sim is None: return CommonQuaternion.empty() return CommonQuaternion.from_quaternion(sim.orientation)
def from_location( location: Union[Location, Math_Location, 'CommonLocation', 'CommonRoutingLocation'] ) -> Union['CommonRoutingLocation', None]: """from_location(location) Convert a vanilla Location object into a CommonRoutingLocation. :param location: An instance of a Location. :type location: Union[routing.Location, sims4.math.Location, CommonLocation, CommonRoutingLocation] :return: An instance of a CommonRoutingLocation or None if the object failed to convert. :rtype: Union[CommonRoutingLocation, None] """ from sims4communitylib.classes.math.common_location import CommonLocation if location is None: return None if isinstance(location, CommonRoutingLocation): return location if isinstance(location, Location): return CommonRoutingLocation(location.position, location.orientation, location.routing_surface) if not isinstance(location, Math_Location) and not isinstance( location, CommonLocation): raise Exception( 'Failed to convert {} with type {} was not of type {}.'.format( location, type(location), type(Math_Location))) routing_surface = location.routing_surface if location.routing_surface is not None else CommonSurfaceIdentifier.empty( ) return CommonRoutingLocation( CommonVector3.from_vector3(location.transform.translation), orientation=CommonQuaternion.from_quaternion( location.transform.orientation), routing_surface=CommonSurfaceIdentifier.from_surface_identifier( routing_surface))
def empty() -> 'CommonTransform': """empty() Create an empty transform. :return: An empty transform. :rtype: CommonTransform """ return CommonTransform(CommonVector3.empty(), CommonQuaternion.empty())
def get_orientation(game_object: GameObject) -> CommonQuaternion: """get_orientation(game_object) Retrieve the orientation of an Object. :param game_object: An instance of an Object. :type game_object: GameObject :return: The orientation of the Object. :rtype: CommonQuaternion """ return CommonQuaternion.from_quaternion(game_object.orientation)
def get_orientation_degrees(sim_info: SimInfo) -> float: """get_orientation_degrees(sim_info) Retrieve the orientation of a Sim represented in degrees. :param sim_info: An instance of a Sim. :type sim_info: SimInfo :return: The orientation of the Sim represented in degrees. :rtype: float """ return CommonQuaternion.to_degrees(CommonSimLocationUtils.get_orientation(sim_info))
def get_orientation_degrees(game_object: GameObject) -> float: """get_orientation_in_degrees(game_object) Retrieve the orientation of an Object in degrees. :param game_object: An instance of an Object. :type game_object: GameObject :return: The orientation of the Object represented in degrees. :rtype: float """ return CommonQuaternion.to_degrees( CommonObjectLocationUtils.get_orientation(game_object))
def empty() -> 'CommonRoutingLocation': """empty() Create an empty location. :return: An empty location. :rtype: CommonRoutingLocation """ return CommonRoutingLocation( CommonVector3.empty(), orientation=CommonQuaternion.empty(), routing_surface=CommonSurfaceIdentifier.empty())
def from_transform(transform: Union[Transform, MathPb2Transform, 'CommonTransform']) -> Union['CommonTransform', None]: """from_transform(transform) Convert a Transform into a CommonTransform. :param transform: An instance of a transform. :type transform: Union[Transform, MathPb2Transform, CommonTransform] :return: An instance of a CommonTransform or None if it failed to convert. :rtype: Union[CommonTransform, None] """ if transform is None: return None if isinstance(transform, CommonTransform): return transform if not isinstance(transform, Transform) and not isinstance(transform, MathPb2Transform): raise Exception('Failed to convert {} with type {} was not of type {}.'.format(transform, type(transform), type(Transform))) # noinspection PyUnresolvedReferences return CommonTransform(CommonVector3.from_vector3(transform.translation), CommonQuaternion.from_quaternion(transform.orientation))
def deserialize( cls, data: Union[str, Dict[str, Any]] ) -> Union['CommonSerializableLocation', None]: if not data: return None if isinstance(data, CommonSerializableLocation): return data data: Dict[str, Any] = data transform_data = data['transform'] translation_data = transform_data['translation'] x = translation_data['x'] y = translation_data['y'] z = translation_data['z'] orientation_data = transform_data['orientation'] or_x = orientation_data['x'] or_y = orientation_data['y'] or_z = orientation_data['z'] or_w = orientation_data['w'] routing_surface = data['routing_surface'] primary_id = routing_surface['primary_id'] secondary_id = routing_surface['secondary_id'] joint_name_or_hash = data['joint_name_or_hash'] slot_hash = data['slot_hash'] parent_ref = data['parent_ref'] translation = CommonVector3(x, y, z) orientation = CommonQuaternion(or_x, or_y, or_z, or_w) transform = CommonTransform(translation, orientation) routing_surface = CommonSurfaceIdentifier(primary_id, secondary_id=secondary_id) return cls( CommonLocation(transform, routing_surface, parent_ref=parent_ref, joint_name_or_hash=joint_name_or_hash, slot_hash=slot_hash))
def can_route_to_position(sim_info: SimInfo, position: CommonVector3, routing_surface: CommonSurfaceIdentifier, orientation: CommonQuaternion=CommonQuaternion.empty()) -> bool: """can_route_to_position(sim_info, position, routing_surface) Determine if a Sim can route to a Location. :param sim_info: An instance of a Sim. :type sim_info: SimInfo :param position: The position to route to. :type position: CommonVector3 :param routing_surface: The routing surface of the target. :type routing_surface: CommonSurfaceIdentifier :param orientation: The orientation of the position. Default is CommonQuaternion.empty(). :type orientation: CommonQuaternion, optional :return: True, if the Sim can route to the specified Position. False, if not. :rtype: bool """ location = CommonLocation( CommonTransform( position, orientation or CommonQuaternion.empty() ), routing_surface ) return CommonSimLocationUtils.can_route_to_location(sim_info, location)