Unity 向量

// 获取两点之间的方向向量
Vector3 direction = (target.position - transform.position).normalized;

// 计算两点距离
float distance = Vector3.Distance(pointA, pointB);

// 计算点积（判断角度关系）
float dotProduct = Vector3.Dot(vectorA, vectorB);

// 计算叉积（获取垂直向量）
Vector3 crossProduct = Vector3.Cross(vectorA, vectorB);

// 使物体朝向目标移动
void MoveTowardsTarget(Transform target)
{
    Vector3 direction = (target.position - transform.position).normalized;
    transform.position += direction * moveSpeed * Time.deltaTime;
}

// 判断物体是否在玩家前方
bool IsInFrontOfPlayer(Vector3 objectPosition)
{
    Vector3 toObject = objectPosition - player.position;
    float dot = Vector3.Dot(player.forward, toObject.normalized);
    return dot > 0.7f; // 角度小于45度
}

// 计算两个向量之间的角度
float angle = Vector3.Angle(vectorA, vectorB);

// 计算带符号的角度（指定旋转轴）
float signedAngle = Vector3.SignedAngle(vectorA, vectorB, Vector3.up);

// 限制角度范围
float clampedAngle = Mathf.Clamp(angle, minAngle, maxAngle);

// 平滑转向目标方向
void SmoothLookAt(Vector3 targetPosition)
{
    Vector3 direction = (targetPosition - transform.position).normalized;
    Quaternion targetRotation = Quaternion.LookRotation(direction);
    transform.rotation = Quaternion.Slerp(
        transform.rotation, 
        targetRotation, 
        rotationSpeed * Time.deltaTime
    );
}

// 判断物体是否在视野范围内
bool IsInView(Vector3 targetPosition)
{
    Vector3 toTarget = targetPosition - camera.position;
    float angle = Vector3.Angle(camera.forward, toTarget);
    return angle < fieldOfView * 0.5f;
}

// 创建旋转
Quaternion rotation = Quaternion.Euler(0, 90, 0); // 绕Y轴旋转90度

// 旋转插值
Quaternion.Slerp(currentRotation, targetRotation, t);

// 创建朝向旋转
Quaternion lookRotation = Quaternion.LookRotation(direction);

// 旋转向量
Vector3 rotatedVector = rotation * Vector3.forward;

// 使物体始终朝向摄像机
void FaceCamera()
{
    Vector3 toCamera = camera.position - transform.position;
    toCamera.y = 0; // 保持水平
    transform.rotation = Quaternion.LookRotation(toCamera);
}

// 围绕点旋转
void OrbitAroundPoint(Vector3 centerPoint)
{
    transform.RotateAround(centerPoint, Vector3.up, orbitSpeed * Time.deltaTime);
}

// 获取物体前方方向
Vector3 forward = transform.forward;

// 获取物体右方方向
Vector3 right = transform.right;

// 获取物体上方方向
Vector3 up = transform.up;

// 获取水平方向（忽略Y轴）
Vector3 horizontalDirection = new Vector3(direction.x, 0, direction.z).normalized;

// 计算侧面接近方向
Vector3 CalculateSideApproach(Vector3 targetPosition, SideApproach side)
{
    Vector3 toTarget = (targetPosition - transform.position).normalized;
    Vector3 sideDirection = (side == SideApproach.Left) ? 
        Vector3.Cross(toTarget, Vector3.up).normalized : 
        Vector3.Cross(Vector3.up, toTarget).normalized;
    
    return Vector3.Lerp(toTarget, sideDirection, 0.5f);
}

// 计算摄像机前方位置
Vector3 GetPositionInFrontOfCamera(float distance)
{
    return camera.position + camera.forward * distance;
}

// 世界坐标转局部坐标
Vector3 localPosition = transform.InverseTransformPoint(worldPosition);

// 局部坐标转世界坐标
Vector3 worldPosition = transform.TransformPoint(localPosition);

// 地面检测
bool IsGrounded()
{
    return Physics.Raycast(
        transform.position,
        Vector3.down,
        groundCheckDistance,
        groundLayer
    );
}

// 平滑移动
Vector3.SmoothDamp(current, target, ref velocity, smoothTime);

// 平滑旋转
Quaternion.SmoothDamp(current, target, ref velocity, smoothTime);

Vector3 PredictLandingPosition(Vector3 start, Vector3 velocity)
{
    // 简单抛物线预测
    float time = (2 * velocity.y) / Physics.gravity.y;
    return start + velocity * time + 0.5f * Physics.gravity * time * time;
}

void FaceCameraHorizontally()
{
    Vector3 toCamera = camera.position - transform.position;
    toCamera.y = 0; // 忽略Y轴差异
    transform.rotation = Quaternion.LookRotation(toCamera);
}

Vector3 GetScreenPosition(Vector3 worldPosition)
{
    return camera.WorldToScreenPoint(worldPosition);
}