unity

How to access properties of a nested class from another script.
Accesso ad una proprietà all’interno di una classe annidata in uno script esterno.

Create an ‘Empty Object’ and attach the scripts:

– SomeClass.cs

using UnityEngine;
using System.Collections;

public class SomeClass : MonoBehaviour // deve essere MonoBehaviour anche questa o non funziona
{
    // proprietà della classe principale
    public int bullets = 10;

    // classe annidata
    
    [System.Serializable] // DEVO dichiarala Serializable o non si può accede da uno script esterno
    public class Something
    {
        // proprietà della classe annidata
        public int fuel = 15;
    }
    public Something Some; // la inserisco in una variabile
}

– SomeOtherClass.cs

using UnityEngine;
using System.Collections;

public class SomeOtherClass : MonoBehaviour
{
    void Start()
    {
        // il nome SomeClass è quello dello script SomeClass.cs
        SomeClass SomeClassScript = transform.GetComponent<SomeClass>();

        // variabile che contiene la classe principale . proprietà
        Debug.Log(SomeClassScript.bullets); // 10

                   // nomeScript.nomeVariabileClasse.proprietà
            Debug.Log(SomeClassScript.Some.fuel); // 15
    }
}

Come funziona?

1. SomeOtherClass.cs

– memorizza in una variabile lo script ottenuto con GetComponent
– richiama la proprietà della classe principale SomeClassScript.bullets
– richiama la proprietà della classe annidata SomeClassScript.Some.fuel

2. SomeClass.cs

– dichiaro l’accessibilità della classe dall’esterno serializzandola [System.Serializable]

– inserisco la classe in una variabile public Something Some
Posso notare che poi la chiamata sarà su – Some – SomeClassScript.Some.fuel

How does classes work in Unity?

Create an ‘Empty Object’ and attack Inventory.cs

// Inventory.cs

using UnityEngine;
using System.Collections;

public class Inventory : MonoBehaviour // il nome del file e della classe sono uguali
{
    // Creating an Instance (an Object) of the Stuff class
    public Stuff myStuff = new Stuff(10, 20, 30, 40); // il nome dell'oggetto è uguale al nome della classe è uguale al costruttore
    // We can create infinite Instances
    public Stuff myOtherStuff = new Stuff(50, 60, 70, 80);
    public Stuff myOtherStuffTwo = new Stuff(); // senza parametri assegna i valori di default
    public Stuff myOtherStuffThree = new Stuff(10.2F); // in base alla natura dei parametri riconosce il metodo, qui cerca lo Stuff() che accetta FLOAT


    void Start()
    {
        Debug.Log(myStuff.bullets); // 10
        Debug.Log(myOtherStuff.grenades); // 60
        myOtherStuff.grenades = 100; // cambio il valore dell'oggetto
        Debug.Log(myOtherStuff.grenades); // 100
        Debug.Log(myOtherStuffTwo.grenades); // 2
        Debug.Log(myOtherStuffThree.magicEnergy); // 10.2

    }

    public class Stuff // nome della classe
    {
        // proprietà
        public int bullets;
        public int grenades;
        public int rockets;
        public int fuel;

        public float magicEnergy;

        // metodo con l'arrivo dei parametri
        public Stuff(int bul, int gre, int roc, int fue) // nome del costruttore uguale a quello della classe
        {
            bullets = bul;
            grenades = gre;
            rockets = roc;
            fuel = fue;
        }

        // metodo senza l'arrivo dei parametri
        public Stuff() // nome del costruttore uguale a quello della classe
        {
            bullets = 1;
            grenades = 2;
            rockets = 3;
            fuel = 4;
        }

        public Stuff(float magicen) {
            magicEnergy = magicen;
        }
    }
}// END Inventory : MonoBehaviour

Rules:

– Inventory.cs and public class Inventory have the same name

– public Stuff myStuff = new Stuff(10, 20, 30, 40); same name in the instance call Stuff

– public Stuff() same name for the method Stuff

– public Stuff myOtherStuffThree = new Stuff(10.2F); Unity recognize automatically the method he needs reading the type of parameters passed, this technique is called ‘Overloading’.