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)