OrbitCamera.cs

CameraController.cs

CameraCollision.cs

Since platformers depend so much on how the movement and camera feels, I took the latter as my main focus for this project. I had to work very closely with the programmer that was working on the player’s movement to make sure that both components fit seamlessly. There’s also a lot of dependencies between camera and movement so we had to plan ahead to make sure the needed properties were easily accessible across components.

The player can move the camera freely around the target in a sphere with radius. The vertical angle is constrained as expected. The euler angles are also looped so that when the angle reaches 360, it starts back at 0.

Code - Orbit Camera

private void ExecuteOrbit()
{
    ConstrainAngles();
    LoopAngle();
    Quaternion newRotation = Quaternion.Euler(new Vector3(orbitAngles.y, orbitAngles.x, 0f));
    _lookRotation = newRotation;
    
    // looking at target
    Vector3 lookDirection = _lookRotation * Vector3.forward;
    Vector3 lookPosition = _focusPoint - lookDirection * currentRadius;
    
    // set pos and rotation
    transform.SetPositionAndRotation(lookPosition, _lookRotation);
}

Follow Camera

Camera will smoothly rotate behind the player when outside the free zone area. If the player is facing the camera, then the camera won’t try to rotate behind the player and it will simply follow its position. The camera will also reset to its default position behind the player when there's no input from the player.

Controller support was one of the goals for this game so it was crucial that the camera could follow the player smoothly when there’s no camera input.

Property:	Function:
Default Height	Pitch angle to default to
Facing Angle	Angle threshold when target is facing camera

Code - Follow Camera

private void ExecuteFollow()
{
    LoopAngle();
    Vector3 direction = target.position - _focusPoint;
    if (direction.magnitude < 0.1f)
    {
        transform.rotation = transform.localRotation;
        return;
    }

    // Convert angles here

    #region Orbit
    // speed for when inside and outside free zone area
    float speed = direction.magnitude < focusRadius - 0.01f ? 0.1f : rotationSpeed;
    
    if (!isFacingCamera)
    {
        if (GameManager.Instance.GetPlayerEntity().GetComponent<PlayerManager>().isGrounded)
        {
            orbitAngles.x = Mathf.LerpAngle(orbitAngles.x, relativeAngle, speed * Time.unscaledDeltaTime);
        }
        else
        {
            orbitAngles.x = Mathf.LerpAngle(orbitAngles.x, relativeAngle, onAirRotationSpeed * Time.unscaledDeltaTime);
        }
    }

    orbitAngles.y = Mathf.LerpAngle(orbitAngles.y, defaultHeight, speed * Time.unscaledDeltaTime);
    Quaternion newRotation = Quaternion.Euler(new Vector3(orbitAngles.y, orbitAngles.x, 0f));
    _lookRotation = newRotation;
    
    // looking at target
    Vector3 lookDirection = _lookRotation * Vector3.forward;
    Vector3 lookPosition = _focusPoint - lookDirection * currentRadius;
    
    // set pos and rotation
    transform.SetPositionAndRotation(lookPosition, _lookRotation);
    #endregion
}

Free Move Zone

The free move zone is an area where the player can move with very little to no camera reaction. The camera targets this area which will move towards the player position depending on how far it is from the center. In our case, we’re just using two easing functions to lerp the position depending if you’re inside or outside the zone.

Property:	Function:
Focus Radius	Free move zone radius
Focus Centering	How fast to center back to target's position

Code - Updating Focus Point

private void UpdateFocusPoint()
{
    Vector3 targetPoint = target.position;
    if (focusRadius > 0f)
    {
        float distance = (targetPoint - _focusPoint).magnitude;
        float t = 1f;
        if (distance > 0.001f && focusCentering > 0f)
        {
            t = Mathf.Pow(1f - focusCentering, Time.unscaledDeltaTime);
        }
        if (distance > focusRadius)
        {
            t = Mathf.Min(t, focusRadius / distance);
        }
        _focusPoint = Vector3.Lerp(targetPoint, _focusPoint, t);
    }
    else
    {
        _focusPoint = targetPoint;
    }
}

Collision Handling

If there’s an object between the target and the camera, the camera will move closer to the target in order to clear it and so it’s not in front anymore. Both collision and occlusion were solved using the following method:

• 5 Raycasts are "shot" from the camera to the target's position: 4 from each corner and 1 from the center.
• The shortest distance from the hit points to the target is calculated and the camera radius is set to this value.

CameraCollision.cs

Code - Collision with clip points

        if (CollisionWithClipPoints(clipPoints, _orbitCamera.Target.position))
        {
            // Shortest collision distance
            _minDistance = GetShortestDistance(clipPoints, _orbitCamera.Target.position);
            _minDistance = Mathf.Clamp(_minDistance, 0, _orbitCamera.Radius);
            _orbitCamera.CurrentRadius = Mathf.SmoothDamp(_orbitCamera.CurrentRadius, _minDistance, ref _camVelocity, smoothTime);

            colliding = true;
        }
        else
        {
            _minDistance = _orbitCamera.Radius;
            _orbitCamera.CurrentRadius = Mathf.SmoothDamp(_orbitCamera.CurrentRadius, _minDistance, ref _camVelocity, smoothReset);
            colliding = false;
        }
    }

• Chest glow VFX
• Outline Shader UniformOutline.shader
• Double side alpha clip shader DoubleSided.shader

• Scriptable Objects: This was the first big project where I tried to use scriptable objects for events and other runtime functionality as described in the link below. Since this approach heavily depends on scene references, because of serialization issues when pushing changes, many times these references were lost and had to be set up again. This caused valuable time to be lost doing double and sometimes triple work. The modularity also makes it easy for changes to be made, sometimes even accidentally. Keeping some functionality strictly in code would've avoided some of these issues. Game Architecture with Scriptable Objects
• Folder and naming conventions: Unfortunately, not enough time was reserved to plan folder structure and naming conventions in the beginning of this project so as one can expect, the folder organization and naming got messy.
• Pair programming: Since the player movement is the main mechanic in this game, we divided player controller and camera in two. It was crucial to work closely with the programmer who was working on the movement since many references are shared between these systems and they both have to work well together. We did it by pair programming extensively and that proved very beneficial for this project.