Derdepersoonscamera in eenheid

Een Derdepersoonscamera is een soort camera die achter de speler wordt geplaatst, meestal iets naar de zijkant verschoven, en die een visuele weergave geeft van het spelniveau en de speler zelf.

Om een ​​Third-Person Shooter (TPS)-camera te maken in Unity gebruiken we een combinatie van een normale spelersbeweging en een third-person-weergave.

Stap 1: Maak de spelercontroller

Eerst zullen we een spelercontroller maken die rotatie en beweging afhandelt:

• Maak een nieuw spelobject (Spelobject -> Leeg maken) en geef het een naam "Player"
• Maak een nieuwe capsule (Spelobject -> 3D-object -> Capsule) en verplaats deze binnen het "Player"-object
• Verwijder de Capsule Collider-component uit de Capsule en verander de positie in (0, 1, 0)
• Maak een nieuw GameObject en noem het "CameraParent" en verplaats het binnen het "Player"-object, verander de positie in (0, 1.64, 0)
• Verplaats de hoofdcamera binnen het "CameraParent"-object en verplaats deze achter de speler (in mijn geval heb ik hem naar deze positie verplaatst: (0,5, 0,6, -2,9))

• Maak een nieuw script, noem het SC_TPSController en plak de onderstaande code erin:

SC_TPSPController.cs

using UnityEngine;

[RequireComponent(typeof(CharacterController))]

public class SC_TPSController : MonoBehaviour
{
    public float speed = 7.5f;
    public float jumpSpeed = 8.0f;
    public float gravity = 20.0f;
    public Transform playerCameraParent;
    public float lookSpeed = 2.0f;
    public float lookXLimit = 60.0f;

    CharacterController characterController;
    Vector3 moveDirection = Vector3.zero;
    Vector2 rotation = Vector2.zero;

    [HideInInspector]
    public bool canMove = true;

    void Start()
    {
        characterController = GetComponent<CharacterController>();
        rotation.y = transform.eulerAngles.y;
    }

    void Update()
    {
        if (characterController.isGrounded)
        {
            // We are grounded, so recalculate move direction based on axes
            Vector3 forward = transform.TransformDirection(Vector3.forward);
            Vector3 right = transform.TransformDirection(Vector3.right);
            float curSpeedX = canMove ? speed * Input.GetAxis("Vertical") : 0;
            float curSpeedY = canMove ? speed * Input.GetAxis("Horizontal") : 0;
            moveDirection = (forward * curSpeedX) + (right * curSpeedY);

            if (Input.GetButton("Jump") && canMove)
            {
                moveDirection.y = jumpSpeed;
            }
        }

        // Apply gravity. Gravity is multiplied by deltaTime twice (once here, and once below
        // when the moveDirection is multiplied by deltaTime). This is because gravity should be applied
        // as an acceleration (ms^-2)
        moveDirection.y -= gravity * Time.deltaTime;

        // Move the controller
        characterController.Move(moveDirection * Time.deltaTime);

        // Player and Camera rotation
        if (canMove)
        {
            rotation.y += Input.GetAxis("Mouse X") * lookSpeed;
            rotation.x += -Input.GetAxis("Mouse Y") * lookSpeed;
            rotation.x = Mathf.Clamp(rotation.x, -lookXLimit, lookXLimit);
            playerCameraParent.localRotation = Quaternion.Euler(rotation.x, 0, 0);
            transform.eulerAngles = new Vector2(0, rotation.y);
        }
    }
}

• Voeg het SC_TPSController-script toe aan het "Player"-object (u zult merken dat het ook een andere component heeft toegevoegd, genaamd Character Controller. Wijzig de middelste waarde in (0, 1, 0))
• Wijs het "CameraParent"-object toe aan de "Player Camera Parent"-variabele

Stap 2: Voeg camerabotsingsdetectie toe

Camera-botsingsdetectie bestaat uit een script dat controleert of er iets tussen de camera en de speler zit, en dat de camera automatisch dichterbij brengt, waardoor wordt voorkomen dat de camera door de objecten heen clipt.

• Maak een nieuw script, noem het SC_CameraCollision en plak de onderstaande code erin:

SC_CameraCollision.cs

using UnityEngine;

public class SC_CameraCollision : MonoBehaviour
{
    public Transform referenceTransform;
    public float collisionOffset = 0.3f; //To prevent Camera from clipping through Objects
    public float cameraSpeed = 15f; //How fast the Camera should snap into position if there are no obstacles

    Vector3 defaultPos;
    Vector3 directionNormalized;
    Transform parentTransform;
    float defaultDistance;

    // Start is called before the first frame update
    void Start()
    {
        defaultPos = transform.localPosition;
        directionNormalized = defaultPos.normalized;
        parentTransform = transform.parent;
        defaultDistance = Vector3.Distance(defaultPos, Vector3.zero);

        //Lock cursor
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }

    // LateUpdate is called after Update
    void LateUpdate()
    {
        Vector3 currentPos = defaultPos;
        RaycastHit hit;
        Vector3 dirTmp = parentTransform.TransformPoint(defaultPos) - referenceTransform.position;
        if (Physics.SphereCast(referenceTransform.position, collisionOffset, dirTmp, out hit, defaultDistance))
        {
            currentPos = (directionNormalized * (hit.distance - collisionOffset));

            transform.localPosition = currentPos;
        }
        else
        {
            transform.localPosition = Vector3.Lerp(transform.localPosition, currentPos, Time.deltaTime * cameraSpeed);
        }
    }
}

• Voeg het SC_CameraCollision-script toe aan de hoofdcamera
• Wijs het "CameraParent"-object toe aan de "Reference Transform"-variabele
• Pas de waarden "Collision Offset" en "Camera Speed" aan voor het geval de camera door de muren heen clipt

De TPS Camera is nu klaar, druk op Play om hem te testen.