­

Video Games Development

Unity Programming – Attributes – Intermediate – CSharp

La dichiarazione di un attributo ci permette di aggiungere dei parametri limite ad una proprietà di una funzione.

Creiamo un Gameobject Cubo ed alleghiamo lo script SpinScript.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
using UnityEngine;
using System.Collections;
 
public class SpinScript : MonoBehaviour
{
    [Range(-100, 100)] // lo specifico sopra la variabile, in Inspector apparirà uno slider
    public int speed = 0; // il cubo non ruoterà finchè non modificherò lo slider
 
    void Update()
    {
        transform.Rotate(new Vector3(0, speed * Time.deltaTime, 0));
    }
}

Selezioniamo il cubo e in Inspector> SpinScript (Script)> Speed spostiamo lo slider

By |CSharp, Unity3D, Video Games Development|Commenti disabilitati su Unity Programming – Attributes – Intermediate – CSharp
Read More

Unity Programming – Delegate – Multicasting – Intermediate – CSharp

delegate è la dichiarazione di un tipo delegato.
delegate è un tipo riferimento che può essere utilizzato per incapsulare un metodo.
In poche parole possiamo incapsulare o o più funzioni (multicast) all’interno di un songolo delegate.

Creare un Empty Object ed allegare lo script MulticastScript.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
using UnityEngine;
using System.Collections;
 
public class MulticastScript : MonoBehaviour
{
    delegate void MultiDelegate();
    MultiDelegate myMultiDelegate; // creo la variabile contenitore
 
 
    void Start()
    {
        myMultiDelegate += PowerUp; // aggiungo il metodo PowerUp()
        myMultiDelegate += TurnRed; // aggiungo il metodo TurnRed()
 
        if (myMultiDelegate != null) // controllo che non sia nullo
        {
            myMultiDelegate(); // stampa Power UP! Turn to RED
        }
 
        myMultiDelegate -= PowerUp; // tolgo il metodo PowerUp()
        myMultiDelegate(); // Turn to RED
 
    }
 
    void PowerUp()
    {
        print("Power UP!");
    }
 
    void TurnRed()
    {
        print("Turn to RED");
    }
}

Con delegate possiamo incapsulare una singola funzione con parametri.

Creare un Empty Object ed allegare lo script DelegateScript.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using UnityEngine;
using System.Collections;
 
 
public class DelegateScript : MonoBehaviour
{
    delegate void MyDelegate(int num); // creo il delegato con una proprietà int
    MyDelegate myDelegate; // notare che i nomi sono uguali
 
 
    void Start()
    {
        myDelegate = PrintNum; // assegno al delegato la funzione PrintNum()
        myDelegate(50); // invio a PrintNum(50)
 
        myDelegate = DoubleNum;
        myDelegate(50);
    }
 
    void PrintNum(int num)
    {
        print("Print Num: " + num);
    }
 
    void DoubleNum(int num)
    {
        print("Double Num: " + num * 2);
    }
 
    // print:
    // 50
    // 100
}
By |CSharp, Gamification, Unity3D, Video Games Development|Commenti disabilitati su Unity Programming – Delegate – Multicasting – Intermediate – CSharp
Read More

Unity Programming – Coroutines – Intermediate – CSharp

Ogni Coroutine viene eseguita in completa indipendenza, condividendo le variabili.
Questo ci permette di generare comportamenti comnplessi senza utilizzare Update()

Creare un Empty Object e allegare lo script CoroutinesExample.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
using UnityEngine;
using System.Collections;
 
public class CoroutinesExample : MonoBehaviour
{
    public int mynumber = 0;
 
    void Start()
    {
        StartCoroutine(MyCoroutine());
        StartCoroutine(MyCoroutineTwo());
    }
 
 
    IEnumerator MyCoroutine()
    {
        print("MyCoroutine 0 sec");
        print("Mycourotine number " + mynumber);
 
        yield return new WaitForSeconds(2f);
 
        print("2 sec");
        mynumber++;
 
        yield return new WaitForSeconds(4f);
 
        print("4 sec");
    }
 
    IEnumerator MyCoroutineTwo()
    {
        print("MyCoroutineTwo 0 sec");
        print("MycourotineTwo number " + mynumber);
 
        yield return new WaitForSeconds(3f);
 
        print("3 sec");
        print("MycourotineTwo number " + mynumber);
    }
 
    // ogni Coroutine viene eseguita in completa indipendenza, condividendo le variabili
    // print:
    // MyCoroutine 0 sec
    // Mycourotine number 0
    // MyCoroutineTwo 0 sec
    // MycourotineTwo number 0
    // 2 sec
    // 3 sec
    // MycourotineTwo number 1
    // 4 sec
}
By |CSharp, Gamification, Unity3D, Video Games Development|Commenti disabilitati su Unity Programming – Coroutines – Intermediate – CSharp
Read More

Unity Programming – Lists – Intermediate – CSharp

Classe List rappresenta un elenco fortemente tipizzato di oggetti accessibili tramite indice. Fornisce metodi per la ricerca, l’ordinamento e la modifica degli elenchi.
Questa classe può contenere ogni tipo di variabile, int, string etc…
Possiamo utilizzare List al posto di Array vista la sua maggiore flessibilità.

Creare lo script BadGuy.cs, NON allegarlo a nessun oggetto
Questo script definisce solamente la struttura della lista

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using UnityEngine;
using System.Collections;
 
 
//This is the class you will be storing
//in the different collections. In order to use
//a collection's Sort() method, this class needs to
//implement the IComparable interface.
public class BadGuy
{
    public string name; // proprietà
    public int power;
 
    // metodo costruttore per ricevere l'input dei parametri
    public BadGuy(string newName, int newPower)
    {
        name = newName;
        power = newPower;
    }
}

Creare un Empty Object ed allegare SomeClass.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
using UnityEngine;
using System.Collections;
using System.Collections.Generic; // per usare la lista
 
public class SomeClass : MonoBehaviour
{
    void Start()
    {
        // istanzio la lista, notare la sintassi
        List<BadGuy> badguys = new List<BadGuy>();
        // popolo la ista
        // lista Add new costruttore (parametri)
        badguys.Add(new BadGuy("Harvey", 50));
        badguys.Add(new BadGuy("Magneto", 100));
        badguys.Add(new BadGuy("Pip", 5));
 
        // inserisce all'indice 1
        badguys.Insert(1, new BadGuy("Joker", 200));
 
        // accedo alla lista con un indice come un array
        int counter = badguys.Count; // conta gli elementi presenti nella lista
        Debug.Log(counter); // print 4
 
        string enemy = badguys[0].name; // lista[indice].nomeproprietà
        Debug.Log(enemy); // print Harvey
        enemy = badguys[1].name; // lista[indice].nomeproprietà
        Debug.Log(enemy); // print Joker
 
        badguys.RemoveAt(0); // rimuove a indice 0
        counter = badguys.Count; // conta gli elementi presenti nella lista
        Debug.Log(counter); // print 3
 
    foreach (BadGuy guy in badguys)
        {
            print(guy.name + " " + guy.power);
        }
        // print Joker 200 Magneto 100 Pip 5
 
        badguys.Clear(); // cancella tutto il contenuto della lista
        counter = badguys.Count; // conta gli elementi presenti nella lista
        Debug.Log(counter); // print 0
    }
}
By |CSharp, Gamification, Unity3D, Video Games Development|Commenti disabilitati su Unity Programming – Lists – Intermediate – CSharp
Read More

Unity Programming – Extensions Methods – Intermediate – CSharp

I metodi di estensione consentono di “aggiungere” metodi ai tipi esistenti senza creare un nuovo tipo derivato, ricompilare o modificare in altro modo il tipo originale. I metodi di estensione sono uno speciale tipo di metodo statico.

Di solito si raggruppano tutti i metodi di estensione in una sola classe per comodità, ad esempio il reset dei parametri e altri metodi che vengono richiamati spesso all’interno del codice.

Creare un Empty Object ed allegare gli scripts:

– ExtensionMethods.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using UnityEngine;
using System.Collections;
 
//It is common to create a class to contain all of your
//extension methods. This class must be static.
public static class ExtensionMethods
{
    //Even though they are used like normal methods, extension
    //methods must be declared static. Notice that the first
    //parameter has the 'this' keyword followed by a Transform
    //variable. This variable denotes which class the extension
    //method becomes a part of.
    public static void ResetTransformation(this Transform trans)
    {
        trans.position = Vector3.zero;
        trans.localRotation = Quaternion.identity;
        trans.localScale = new Vector3(1, 1, 1);
    }
}

– SomeClass.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using UnityEngine;
using System.Collections;
 
public class SomeClass : MonoBehaviour
{
    void Start () {
        //Notice how you pass no parameter into this
        //extension method even though you had one in the
        //method declaration. The transform object that
        //this method is called from automatically gets
        //passed in as the first parameter.
        transform.ResetTransformation();
    }
}

Notare come è facile richiamare il reset dell’oggetto – transform.ResetTransformation(); –

By |CSharp, Unity3D, Video Games Development|Commenti disabilitati su Unity Programming – Extensions Methods – Intermediate – CSharp
Read More