­

indiegamedev

  • Home
  • Tag: indiegamedev

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

Unity Programming – Interfaces – Intermediate – CSharp

Unity Programming – Interfaces – Intermediate – CSharp

Un’interfaccia è un gruppo completamente astratto di membri che può essere considerato come la definizione di un contratto: chi implementa una interfaccia si impegna a scrivere il codice per ciascun metodo.

La classe che implementa un’interfaccia deve fornire l’implementazione di TUTTI i suoi metodi e delle sue proprietà, in questo caso però non c’è bisogno della parola chiave override, è sufficiente che i metodi definiti abbiano lo stesso nome con cui sono dichiarati nell’interfaccia.

Le interfacce non possono avere dei loro metodi o proprietà ma servono per stabilire delle relazioni tra le classi.

Nel caso di classi avremo CLASSE A padre -> eredita -> CLASSE B figlio.

Nel caso delle interfacce avremo INTERFACCIA A -> CLASSE B che implementa i metodi indicati nell’interfaccia.

Le interfacce si usano al posto dell’ereditarietà quando non ha senso impostare una parentela fra le classi. Ad esempio MURO ed AUTO non possono avere una relazione di parentela, ma possono essere accumunate dall’interfaccia DANNEGGIABILE

DANNEGGIABILE -> MURO

DANNEGGIABILE -> AUTO

L’interfaccia viene dichiarata con I maiuscola + maiuscola nome interfaccia

Creiamo un Empty Object e alleghiamo gli scripts:

– Interfaces.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;
 
//This is a basic interface with a single required
//method.
 
public interface IKillable
    {
    void Kill();
    }
 
//This is a generic interface where T is a placeholder
//for a data type that will be provided by the
//implementing class.
 
public interface IDamageable<T>
    {
    void Damage(T damageTaken);
    }

– Avatar.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using UnityEngine;
using System.Collections;
 
public class Avatar : MonoBehaviour, IKillable, IDamageable<float>
{
    //The required method of the IKillable interface
    public void Kill()
    {
    //Do something fun
    }
 
    //The required method of the IDamageable interface
    public void Damage(float damageTaken)
    {
    //Do something fun
    }
}

Avatar eredita da MonoBehaviour o estende MonoBehaviour ed implementa IKillable e IDamageable.
Ogni classe che implementa IKillable e IDamageable dovrà avere void Kill() e void Damage().
L’interfaccia è utile per dare regole ben precise nella costruzione delle classi, specialmente se sono affidate a team differenti.

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