Rook's Quest

Quaternion startRotation = player.transform.rotation;
Quaternion endRotation = Quaternion.Euler(0, targetYAngle, 0);
float elapsed = 0f;

while (elapsed < duration)
{
    elapsed += Time.deltaTime;
    player.transform.rotation = Quaternion.Slerp(startRotation, endRotation, elapsed / duration);
    yield return null;
}

// we use DOTween for interpolation and easing
player.transform.DORotate(new Vector3(0, targetYAngle, 0), duration).SetEase(Ease.OutSine);
yield return player.transform
    .DORotate(new Vector3(0, targetYAngle, 0), 0)
    .WaitForCompletion();

private void DrawTrajectory(float force)
{
    frameCounter++;
    Vector3 start = ball.position;
    Vector3 targetPos = Target.position;
    Vector3 toTarget = (targetPos - start);
    float toTargetLen = toTarget.magnitude;
    Vector3 toTargetN = (toTargetLen > 1e-5f) ? (toTarget / toTargetLen) : Vector3.forward;
    float curveVal = (curveSlider != null) ? curveSlider.value : 0f;

    bool inputsChanged =
        cachedCharging != isCharging ||
        Mathf.Abs(cachedForce - force) > 0.001f ||
        Mathf.Abs(cachedCurveVal - curveVal) > 0.001f ||
        (cachedStart - start).sqrMagnitude > 1e-4f ||
        (cachedTargetPos - targetPos).sqrMagnitude > 1e-4f;

    if (!inputsChanged && isCharging && (frameCounter % recomputeEveryNFrames != 0))
    {
        trajectoryLine.startColor = startColorCached;
        trajectoryLine.endColor = endColorCached;
        return;
    }

    cachedCharging = isCharging;
    cachedForce = force;
    cachedCurveVal = curveVal;
    cachedStart = start;
    cachedTargetPos = targetPos;
    cachedToTarget = toTargetN;

    if (!isCharging)
    {
        trajCount = 2;
        trajPoints[0] = start;
        trajPoints[1] = targetPos;

        trajectoryLine.positionCount = trajCount;
        trajectoryLine.SetPosition(0, trajPoints[0]);
        trajectoryLine.SetPosition(1, trajPoints[1]);

        trajectoryLine.startColor = startColorCached;
        trajectoryLine.endColor = endColorCached;
        return;
    }

    Vector3 sideDir = Vector3.Cross(Vector3.up, toTargetN).normalized;
    Vector3 lateralAccel = sideDir * (curveVal * curveFactor);

    trajCount = 0;
    Vector3 pos = start;
    Vector3 vel = toTargetN * force;
    float traveled = 0f;

    trajPoints[trajCount++] = pos;

    float dt = trajectoryTimeStep;
    Vector3 acc = Physics.gravity + lateralAccel;
    float maxDist = maxRenderDistance;
    int maxPts = Mathf.Min(maxTrajectoryPoints, trajPoints.Length - 1);

    for (int i = 0; i < maxPts; i++)
    {
        Vector3 nextVel = vel + acc * dt;
        Vector3 nextPos = pos + nextVel * dt;

        Vector3 seg = nextPos - pos;
        float segLen = seg.magnitude;

        if (traveled + segLen > maxDist)
        {
            float remain = maxDist - traveled;
            Vector3 dir = segLen > 1e-6f ? (seg / segLen) : Vector3.forward;
            nextPos = pos + dir * remain;
            trajPoints[trajCount++] = nextPos;
            break;
        }

        int hits = 0;
        float castDist = Mathf.Max(0f, vel.magnitude * dt);
        if (castDist > 1e-6f)
            hits = Physics.RaycastNonAlloc(pos,
			vel.normalized, ray1, castDist, ~0, QueryTriggerInteraction.Ignore);

        if (hits > 0)
        {
            var hit = ray1[0];
            trajPoints[trajCount++] = hit.point;

            vel = Vector3.Reflect(vel, hit.normal) * bounceFactor;
            pos = hit.point + vel.normalized * 0.01f;

            Vector3 prev = trajPoints[trajCount - 2];
            traveled += Vector3.Distance(prev, hit.point);
            continue;
        }

        vel = nextVel;
        pos = nextPos;
        traveled += segLen;

        trajPoints[trajCount++] = pos;
    }

    trajectoryLine.positionCount = trajCount;
    for (int i = 0; i < trajCount; i++)
        trajectoryLine.SetPosition(i, trajPoints[i]);

    trajectoryLine.startColor = startColorCached;
    trajectoryLine.endColor = endColorCached;
}

private void DrawTrajectory(float force)
{
    Vector3 start = ball.position;
    Vector3 toTarget = (Target.position - start);
    float len = toTarget.magnitude;
    Vector3 dirN = (len > 1e-5f) ? (toTarget / len) : Vector3.forward;

    if (!isCharging)
    {
        trajectoryLine.positionCount = 2;
        trajectoryLine.SetPosition(0, start);
        trajectoryLine.SetPosition(1, Target.position);
        trajectoryLine.startColor = 
				new Color(lineBaseColor.r, lineBaseColor.g,
								lineBaseColor.b, 1f);
        trajectoryLine.endColor   =
				new Color(lineBaseColor.r, lineBaseColor.g, 
								lineBaseColor.b, tailAlpha);
        return;
    }

    float curveVal = curveSlider != null ? curveSlider.value : 0f;
    Vector3 sideDir = Vector3.Cross(Vector3.up, dirN).normalized;
    Vector3 lateralAccel = sideDir * (curveVal * curveFactor);
    Vector3 accel = Physics.gravity + lateralAccel;
    Vector3 initialVel = dirN * Mathf.Max(0f, force);
   
    int count = burstPreview.Predict(
        start: start,
        initialVelocity: initialVel,
        accel: accel,
        dt: trajectoryTimeStep,
        maxPoints: maxTrajectoryPoints,
        maxDistance: maxRenderDistance
    );

    int finalCount = count;
    for (int i = 0; i < count - 1; i++)
    {
        Vector3 p0 = burstPreview.GetPoint(i);
        Vector3 p1 = burstPreview.GetPoint(i + 1);
        Vector3 seg = p1 - p0;
        float segLen = seg.magnitude;
        if (segLen <= 1e-6f) continue;

        if (Physics.Raycast(p0, seg / segLen, out var hit, segLen))
        {
            trajBuffer[0] = burstPreview.GetPoint(0);
            for (int j = 1; j <= i; j++) trajBuffer[j] = 
								burstPreview.GetPoint(j);
            trajBuffer[i + 1] = hit.point;
            finalCount = i + 2;
            goto PUSH;
        }
    }
  
    for (int i = 0; i < count; i++)
        trajBuffer[i] = burstPreview.GetPoint(i);

PUSH:
    trajectoryLine.positionCount = finalCount;
    for (int i = 0; i < finalCount; i++)
        trajectoryLine.SetPosition(i, trajBuffer[i]);

    trajectoryLine.startColor =
		new Color(lineBaseColor.r, lineBaseColor.g, lineBaseColor.b, 1f);
    trajectoryLine.endColor   =
		new Color(lineBaseColor.r, lineBaseColor.g, lineBaseColor.b, tailAlpha);
}