Creare un nemico che spara una palla di fuoco

Nella precedente lezione abbiamo visto come assegnare un sistema di salute a un nemico, e creare un proiettile che sia in grado di diminuire questo parametro, portando in definitiva alla sconfitta dell’avversario che sarà così distrutto. Il problema, a questo punto, è far sì che quel proiettile venga effettivamente sparato dal nostro protagonista. Anche in questo caso, quindi, ci tornerà utile uno script, che possiamo trovare qui di seguito e che chiameremo WeaponFire:

using UnityEngine;
 
public class WeaponFire: MonoBehaviour {
  // Il prefab della palla di fuoco.
  public Transform shotPrefab;
 
  // Il tasso di frequenza del lancio della palla di fuoco.
  public float shootingRate = 0.25f;
 
  // Il tempo di ricarica tra una palla di fuoco e l’altra.
  private float shootCooldown;
 
  void Start() {
    shootCooldown = 0f;
  }
 
  void Update() {
    if (shootCooldown & gt; 0) {
      shootCooldown -= Time.deltaTime;
    }
  }
 
  // Richiama l’altro script dello sparo.
  // Creazione della nuova palla di fuoco.
  public void Attack(bool isEnemy) {
    if (CanAttack) {
      shootCooldown = shootingRate;
 
      // Creare una nuova palla di fuoco.
      var shotTransform = Instantiate(shotPrefab) as Transform;
 
      // Gestire la posizione.
      shotTransform.position = transform.position;
 
      // Determinare se chi colpisce è un nemico o meno.
      ShootFireball shot = shotTransform.gameObject.GetComponent();
      if (shot != null) {
        shot.isEnemyShot = isEnemy;
      }
 
      // Far sparare alla sinistra del nemico.
      EnemyScript move = shotTransform.gameObject.GetComponent();
      if (move != null) {
        move.direction = this.transform.right;
      }
    }
  }
 
  // Chiedere se può sparare un’altra palla di fuoco.
  public bool CanAttack {
    get {
      return shootCooldown & lt; = 0f;
    }
  }
}

Attacchiamo WeaponFire al nostro personaggio. Entrando nell’Inspector, vedremo che c’è uno slot vuoto, alla voce Shot Prefab. Cliccandoci apriremo il menu Select Transform, da cui potremo selezionare il nostro proiettile. Manca ancora, tuttavia, l’istruzione tramite codice che determina che quando clicchiamo su un tasto, questo genera una palla di fuoco. Creiamo un nuovo script da attaccare al nostro personaggio principale e inseriamo il seguente codice:

using UnityEngine;
public class ShootInput: MonoBehaviour {
  void Start() {}
 
  void Update() {
 
    // Comandi per lanciare palla di fuoco.
    bool shoot = Input.GetButtonDown("Fire1");
    shoot |= Input.GetButtonDown("Fire2");
 
    if (shoot) {
      WeaponFire weapon = GetComponent();
      if (weapon != null) {
        // Un if falso perché il giocatore non è un nemico.
        weapon.Attack(false);
      }
    }
 
    // ...
  }
}

Tradotto nel nostro linguaggio, questo significa che quando premiamo CTRL o il click sinistro del mouse, il nostro personaggio lancerà una sfera di fuoco. Come variabile esposta abbiamo anche lo Shooting Rate, ossia un brevissimo periodo in cui non sarà possibile sparare. Naturalmente i designer possono modificare questo valore: in un gioco, per esempio, una vecchia arma potrebbe non essere in grado di “ricaricarsi” tanto velocemente; in uno sparatutto bullet hell, al contrario, non ci sarà alcuna pausa, proprio per determinare un ritmo di gioco serrato e incessante.

Per rendere le cose più interessanti, tuttavia, è bene che anche la nostra gelatina si difenda in qualche modo. Ecco perché assegneremo anche lei la possibilità di sparare. Cominciamo con il duplicare il proiettile, semplicemente selezionandolo fireball nella Hierarchy e duplicandolo, chiamandolo enemybullet. Nelle proprietà di enemybullet nell’Inspector, alla voce Sprite, scegliamo un’altra immagine che avremo importato negli asset, nel nostro caso una fiamma azzurra. Occorre, adesso, fare una doverosa premessa.

Come creare un prefab

Come è possibile notare, quando abbiamo creato fireball, o in questo caso enemybullet, questi oggetti rimangono sulla scena. Se li cancelliamo, non sarà più possibile richiamarli da altri GameObject, il che significa che né il personaggio né il nemico potranno utilizzarli. Come risolvere, allora? Creiamo un prefab. Nella finestra degli asset clicchiamo su Create, Prefab e creeremo uno di questi blocchetti. Poi, trasciniamo dalla Hierarchy l’oggetto e le sue regole, che vogliamo trasformare in un prefab. A questo punto, anche se non sarà in scena, il proiettile potrà essere richiamato dalle altre funzioni del programma. Nel nostro caso specifico, il collegamento tra Weapon Fire, lo script assegnato al personaggio principale, sarà saltato, per cui dovremo trascinare il nuovo prefab nella casella Shot Prefab.

Creare un nemico che spara

A questo punto, assegniamo lo script WeaponFire al nemico. Nell’Inspector, alla voce shot Prefab, aggiungiamo il prefab enemybullet. A questo punto, ci servirà uno script che dia l’istruzione al nemico di sparare. Potremmo dargli comportamenti più avanzati (per esempio, spara quando vedi il giocatore), ma per il momento ci limiteremo a dirgli semplicemente di sparare a ogni frame. Creiamo quindi lo script EnemyShoot e assegniamolo al nostro nemico. Il nostro nemico, a questo punto, sparerà. Nella prossima lezione, vedremo come impostare la direzione dello sparo e come creare un sistema di danni che influisce sul nostro personaggio.