Menu
CoddyTech

Ricicla la strada

Lezione 7 di 21 del corso Gioco Unity: Corsie nel cielo di Coddy.

Sette segmenti sono 140 unità di strada. A 10 unità al secondo, la strada finisce in 14 secondi. Creare un nuovo segmento ogni volta che serve e distruggere quelli vecchi funzionerebbe, ma c’è un modo più economico: un segmento che è passato dietro al corridore viene spostato in avanti e riutilizzato.

Un segmento si trova completamente dietro quando il suo centro supera -chunkLength. Con sette segmenti in fila, spostarlo in avanti di sette lunghezze lo porta subito dopo l’ultimo:

if (chunk.position.z < -chunkLength)
{
    chunk.position += Vector3.forward * chunkLength * chunks.Count;
}

Riutilizzare gli oggetti invece di distruggerli e crearne di nuovi si chiama pooling. Sette segmenti formano una strada infinita.

challenge icon

Sfida

Facile

Riutilizza ogni tratto di strada una volta che passa dietro il corridore.

  1. In Road.Update, dopo aver spostato un tratto, controlla se chunk.position.z < -chunkLength.
  2. In tal caso, spostalo in avanti di chunkLength * chunks.Count, come sopra.

Premi «Gioca» e attendi 15 secondi: la strada non finisce mai. Poi premi «Verifica».

Provalo tu

using UnityEngine;

public class Runner : MonoBehaviour
{
    public float laneWidth = 2.5f;
    public float laneSpeed = 16f;
    public float jumpHeight = 1.6f;
    public float gravity = -40f;
    public float slideTime = 0.7f;

    public int lane;

    private CharacterController controller;
    private float fallSpeed;
    private float slide;

    void Start()
    {
        controller = GetComponent<CharacterController>();
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.A) || Input.GetKeyDown(KeyCode.LeftArrow)) lane = Mathf.Max(-1, lane - 1);
        if (Input.GetKeyDown(KeyCode.D) || Input.GetKeyDown(KeyCode.RightArrow)) lane = Mathf.Min(1, lane + 1);
        bool jump = Input.GetKeyDown(KeyCode.W) || Input.GetKeyDown(KeyCode.UpArrow) || Input.GetKeyDown(KeyCode.Space);
        if (jump && controller.isGrounded)
        {
            fallSpeed = Mathf.Sqrt(jumpHeight * -2f * gravity);
            StopSlide();
        }
        if ((Input.GetKeyDown(KeyCode.S) || Input.GetKeyDown(KeyCode.DownArrow)) && controller.isGrounded)
        {
            slide = slideTime;
            Resize(0.5f);
        }

        if (slide > 0f)
        {
            slide -= Time.deltaTime;
            if (slide <= 0f) StopSlide();
        }

        if (controller.isGrounded && fallSpeed < 0f) fallSpeed = -2f;
        fallSpeed += gravity * Time.deltaTime;

        float targetX = lane * laneWidth;
        float x = Mathf.MoveTowards(transform.position.x, targetX, laneSpeed * Time.deltaTime);
        Vector3 move = new Vector3(x - transform.position.x, fallSpeed * Time.deltaTime, 0f);
        controller.Move(move);
    }

    void StopSlide()
    {
        if (transform.localScale.y < 1f) Resize(1f);
        slide = 0f;
    }

    void Resize(float height)
    {
        controller.enabled = false;
        transform.position += Vector3.up * (height - transform.localScale.y);
        transform.localScale = new Vector3(1f, height, 1f);
        controller.enabled = true;
    }
}

Tutte le lezioni di Gioco Unity: Corsie nel cielo

Esercitati da solo: Playground Unity