Componenti piccoli

Fa parte della sezione Architettura dei giochi in Unity del percorso Unity di Coddy. Lezione 1 di 50.

Un GameObject è un elenco di componenti e ogni script che scrivi è uno di questi. I giochi Unity si realizzano assegnando a ogni script un compito e mettendo più script su un oggetto. Il movimento, gli spari e i punti vita di un giocatore potrebbero trovarsi tutti in un unico PlayerController, ma, come tre componenti, Mover, Shooter e Health, ognuno può essere aggiunto anche ad altri oggetti:

public class Health : MonoBehaviour
{
    public int hp = 3;

    public void TakeDamage(int amount)
    {
        hp -= amount;
        if (hp <= 0)
        {
            Destroy(gameObject);
        }
    }
}

Giocatore: Mover, Shooter, Health
Torretta: Shooter, Health
Cassa: Health

Con le semplici classi C# potresti invece creare un albero: Character, poi ShootingCharacter : Character, poi Player : ShootingCharacter. Una torretta spara ma non cammina mai, mentre una cassa si rompe soltanto, quindi ogni nuovo tipo di oggetto richiede di ristrutturare l'albero. Con i componenti, un nuovo tipo di oggetto è una nuova combinazione di script già esistenti, assemblati nell'Inspector, e ogni script può avere lì i propri valori: un Mover lento su un oggetto, uno veloce su un altro.

I componenti sullo stesso oggetto condividono il suo Transform, quindi ciascuno dovrebbe modificare solo la parte di cui è responsabile. Un Mover che aggiunge valori a x e z con transform.position += lascia invariata y, così un Jumper sullo stesso oggetto può ancora modificare l'altezza. Un Mover che imposta l'intera posizione su new Vector3(x, 0.5f, z) riporterebbe y al suo valore iniziale a ogni fotogramma, annullando il salto.

Sfida

Facile

Boat.cs svolge tre compiti contemporaneamente: le frecce (l’azione Move) governano la barca, la barca ondeggia sulle onde e la sua lampada lampeggia. Anche l’anatra ha bisogno di ondeggiare, e la boa ha bisogno sia di ondeggiare sia di lampeggiare, quindi la scena ha già assegnato loro i componenti Bobber e Blinker, mentre la barca li ha tutti e tre. Suddividi Boat.cs in questi componenti:

Bobber: ogni oggetto ondeggia attorno all’altezza iniziale, di height unità verso l’alto e verso il basso, alla propria speed (l’Inspector imposta entrambi i valori). Bobber modifica solo la coordinata y della posizione, così la barca può continuare a essere governata.
Blinker: accende e spegne lamp (un Renderer) ogni interval secondi.
Boat mantiene solo il controllo: elimina l’ondeggiamento e il lampeggiamento, insieme ai relativi campi.

Premi Play e governa la barca, poi premi Check.

Provalo tu

using UnityEngine;
using UnityEngine.InputSystem;

// Un solo script, tre compiti: sterzare, oscillare su e giù e lampeggiare.
public class Boat : MonoBehaviour
{
    public float speed = 3f;
    public float bobHeight = 0.1f;
    public float bobSpeed = 2f;
    public Renderer lamp;
    public float blinkInterval = 0.5f;

    private InputAction moveAction;
    private float startY;
    private float blinkTimer;

    void Start()
    {
        moveAction = InputSystem.actions.FindAction("Move");
        startY = transform.position.y;
    }

    void Update()
    {
        // sterzata
        Vector2 input = moveAction.ReadValue<Vector2>();
        transform.position += new Vector3(input.x, 0f, input.y) * speed * Time.deltaTime;

        // oscillazione verticale
        Vector3 p = transform.position;
        p.y = startY + Mathf.Sin(Time.time * bobSpeed) * bobHeight;
        transform.position = p;

        // lampeggiamento
        blinkTimer += Time.deltaTime;
        if (blinkTimer >= blinkInterval)
        {
            blinkTimer -= blinkInterval;
            lamp.enabled = !lamp.enabled;
        }
    }
}