Tutorials - Spieleentwicklung

1. Events, wozu sind die gut?

Events sind sehr praktisch. Anstatt deine Objekte im Spiel fest per Methodenaufruf zu verbinden und Daten so auszutauschen, solltest Du möglichst oft Events verwenden.

So vermeidest Du Abhängigkeiten und kannst dein Programm auf jeden Fall immer sehr einfach vergrößern oder verkleinern, ohne dass Du durch Abhängigkeiten Probleme bekommst.

Das funktioniert vom Prinzip her so:

Eventlistener melden sich auf die Events an, die von der jeweiligen Klasse genutzt werden soll. Die Klasse, die eine Information von einer anderer Klasse verwenden möchte, „sagt“ also dass sie an dieser Information interessiert ist und wartet dann bis der Event ausgelöst wird.

Das ist im Grunde das Gegenteil von direkten Methodenaufrufen. Mehrere Listener können sich beim gleichen Event anmelden, obwohl dieser nur ein mal ausgelöst wird. Dadurch lässt sich ein Programm sehr einfach erweitern.

Ein weiterer Vorteil ist, dass bei Wegfall eines Listeners in einer Instanz, diese zwar am Event nicht mehr teilnimmt, der Rest des Programms funktioniert ab weiterhin. Dies ist bei direkten Methodenaufrufen oft nicht der Fall, da die einzelnen Objekte dadurch stark von einander abhängen. Ein Fehler in einer Instanz führt dann oft zu Folgefehlern.

2. Unity Events verwenden

In diesem Tutorial verwenden wir UnityEvents und SystemEvents. Im folgenden Beispiel wird ein UnityEvent instanziiert und bei Zerstörung der Klasse Enemy ausgelöst.

using UnityEngine;
using UnityEngine.Events;

public class Enemy : MonoBehaviour
{
    const int points = 100;
    public static UnityEvent<int> onDead = new UnityEvent<int>();

   [ContextMenu(nameof(Die))]
    private void Die()
    {
        //Enemy is dead
        onDead.Invoke(points);
    }
}

Anschließend nimmt eine andere Klasse am Event teil, d.h. sie meldet einen Listener an. Falls das Objekt GameManager mal deaktiviert wird, muss Sie sich beim Event auch wieder abmelden.

using UnityEngine;

public class Gamemanager : MonoBehaviour
{
    int score;
    private void OnEnable()
    {
        Enemy.onDead.AddListener(NewScore);
    }
    private void OnDisable()
    {
        Enemy.onDead.RemoveListener(NewScore);
    }

    void NewScore( int points)
    {
        score += points;
		Debug.Log("New Score:" + score);
    }
}

Werbung (Affiliate - ich bekomme eine kleine Provision, dein Preis ändert sich nicht)

3. Unity Events im Inspector verwenden

Im obigen Beispiel war der UnityEvent direkt in anderen Klassen verwendbar, da es public static war. Ohne das Schlüsselwort static hätte wir zuvor eine Referenz auf die Klasse erlangen müssen.

Im folgenden Beispiel wollen wir das Event aber im Inspector verwenden, denn der große Vorteil von UnityEvents ist, dass man Ihnen Methoden im Inspector zuweisen kann.

using UnityEngine;
using UnityEngine.Events;

public class Enemy : MonoBehaviour
{
    const int points = 100;

    //UnityEvent soll im Inspector verwendbar sein  
    [SerializeField] UnityEvent<int> onDead;

    [ContextMenu(nameof(Die))]
    private void Die()
    {
        //Enemy is dead
        onDead.Invoke(points);		
    }
}

Diesmal meldet sich das andere Script, welches das Event verwendet, nicht selbst einen Listener an. Es stellt stattdessen nur ein öffentlich aufrufbare Methode zur Verfügung.

using UnityEngine;

public class Gamemanager : MonoBehaviour
{
    int score;
    public void NewScore(int points)
    {
        score += points;
    }
}

Jetzt können wir den Inspector nutzen, um die Methode des anderen Scripts (NewScore vom Gamemanager) aufzurufen. Das kann insbesondere praktisch sein, wenn auch Nichtprogrammier am Projekt arbeiten. Oder wenn Du eigene Frameworks im Assetstore anbieten möchtest, die auch für Anfänger verwendbar sein sollen.

Im Unity Inspector ist der Event zuweisbar

4. System-Events verwenden

Wir können natürlich auch Events von System benutzen. Hier im Beispiel verwende ich später den Typen Action, der von Delegate abgeleitet ist.

Delegates können eine Referenz auf eine Methode speichern. Diese ist dann über den Delegaten aufrufbar. Im folgenden ein Event mit Delegate.

using UnityEngine;

public class Enemy : MonoBehaviour
{
    const int points = 100;
    
    //Hier ist delegate verwendet, nur als Beispiel, so nicht gut geeignet
    public delegate void OnDead (int points);
    public static event OnDead onDead;

    [ContextMenu(nameof(Die))]
    private void Die()
    {
        //Enemy is dead
        onDead.Invoke(points);
    }
}

In der Praxis ist es aber einfacher generische Delegaten, wie z.B. Action zuverwenden, da so nicht für jedes einzelne Event ein separates Object erzeugt werden muss.

using UnityEngine;
using System;

public class Enemy : MonoBehaviour
{
    const int points = 100;
    public static Action<int> onDead;

    [ContextMenu(nameof(Die))]
    private void Die()
	{
        //Enemy is dead
        onDead.Invoke(points);
    }
}

Ob mit delegate direkt oder mit Action, der Eventlistener wird in beiden Fällen so angemeldet:

using UnityEngine;

public class Gamemanager : MonoBehaviour
{
    int score;
    private void OnEnable()
    {
        Enemy.onDead += NewScore;
    }
    private void OnDisable()
    {
        Enemy.onDead -= NewScore;
    }

    void NewScore( int points)
    {
        score += points;
		Debug.Log("New Score:" + score);
    }
}

5. Eigenes Eventsystem

Oft macht es auch Sinn, sich ein eigenes Eventsystem aufzubauen, um seine Events übersichtlich zu verwalten.

Eine ganz einfache Art davon wäre eine Klasse, in der verschiedene Events gesammelt sind. So muss man nicht überlegen, wo ein bestimmtes Event implementiert ist.

using UnityEngine;
using System;

public enum GameState { None=1, Pause=2, Run = 3, Options = 4 }
public class GameActions
{
    public static Action<int> onPlayerScore;

    public static Action<string> onLevelLoaded;

    public static Action<GameState> onChangeGameState;

    public static Action<float> onEnemyInsideRange;
}

6. Eigenes Eventsystem mit ScriptableObjects

Bei größeren Projekten macht eine Verwaltung der einzelnen Events in Listen durchaus Sinn. Im folgenden Beispiel ist eine einfaches Eventsystem mit ScriptableObjects implementiert.

Zuerst der jeweilige GameEvent:

using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu]
public class GameEvent : ScriptableObject
{
	private List<GameEventListener> listeners =
		new List<GameEventListener>();

	public void Raise()
	{
		for (int i = listeners.Count - 1; i >= 0; i--)
			listeners[i].OnEventRaised();
	}

	public void RegisterListener(GameEventListener listener)
	{ listeners.Add(listener); }

	public void UnregisterListener(GameEventListener listener)
	{ listeners.Remove(listener); }
}

Fehlt noch die Verwaltung der Listener:

using UnityEngine;
using UnityEngine.Events;

public class GameEventListener : MonoBehaviour
{
        [SerializeField] GameEvent Event;
        [SerializeField] UnityEvent Response;

        private void OnEnable()
        { Event.RegisterListener(this); }

        private void OnDisable()
        { Event.UnregisterListener(this); }

        public void OnEventRaised()
        { Response.Invoke(); }
}

Über den Inspector können wieder per Drag & Drop Methoden zugewiesen werden, die öffentlich sein müssen.

using UnityEngine;

public class Gamemanager : MonoBehaviour
{
    int score;
    public void NewScore(int points)
    {
        score += points;
    }
}

Nun können wir viele verschiedene GameEvent-Assets als ScriptableObject erzeugen und verwenden:

Eigenes Eventsystem mit ScriptableObject

Auslösen können wir das Event in der Enemy-Klasse jetzt so:

using UnityEngine;
public class Enemy : MonoBehaviour
{   
    [SerializeField] GameEvent onDead;

    [ContextMenu(nameof(Die))]
    private void Die()
    {
        //Enemy is dead
        onDead.Raise();
    }
}

7. Eventsystem mit ScriptableObjects und Parameter

Dir ist sicher aufgefallen, dass wir beim obigen Eventsystem keine Parameterübergeben können.

Das bedeutet wir benötigen für jeden Typen, den wir per GameEvent übergeben wollen, eine angepasste Version des GameEvents und des Listeners.

Die einfachste, aber nicht so schöne Möglichkeit dies zu umgehen, wäre jetzt einfach den Typen object zu verwenden. Object ist die ultimative Basisklasse aller .NET-Klassen. Das bedeutet jede Klasse lässt sich in object konvertieren und umgekehrt.

Wir müssen also bei Verwendung des Parameters (nach dem der Event diese übergeben hat) wissen von welchem Typ der angenommene Wert ist. Das konvertieren kostet ausserdem zusätzlich Rechenleistung. Und naja, Typsicherheit ist dann doch was anderes eigentlich ;-).

Zum Glück gibts aber noch Interfaces und generische Typparameter, die uns den Aufwand verschiedener Event-Versionen in Grenzen halten.

Zuerst ein Interface mit der Methode "OnEventRaised()". Jede Klasse, die an diesem Interface teilnimmt, muss diese Methode implementieren.

public interface IEventListener<T>
{
    void OnEventRaised(T parameter);
}

In der Liste, die zuvor den GameEventListener gespeichert hat, speichern wir jetzt das Interface "IEventListener". Zudem verwenden wir einen generischen Typparameter für die Klasse und die Methoden.

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using System;

public class GameEvent<T>: ScriptableObject
{
	private List<IEventListener<T>> listeners =
		new List<IEventListener<T>>();

	public void Raise( T value )
	{
		for (int i = listeners.Count - 1; i >= 0; i--)
			listeners[i].OnEventRaised( value );
	}

	public void RegisterListener(IEventListener<T> listener)
	{ listeners.Add(listener); }

	public void UnregisterListener(IEventListener<T> listener)
	{ listeners.Remove(listener); }
}

Im GameEventListener verwenden wir ebenfalls einen generischen Typparameter und das obige Interface.

using UnityEngine;
using UnityEngine.Events;

public class GameEventListener<T> : MonoBehaviour, IEventListener<T>
{
    [SerializeField] GameEvent<T> gameEvent;
    [SerializeField] UnityEvent<T> response;

    private void OnEnable()
    { gameEvent.RegisterListener(this); }

    private void OnDisable()
    { gameEvent.UnregisterListener(this); }

    public void OnEventRaised( T value )
    { 
        response.Invoke( value );
    }
}

Dank Vererbung können wir nun Listener mit unterschiedlichen Parametern ableiten.

public class IntGameEventListener : GameEventListener<int> { }

Anschließend ist es möglich, dem GameEvent einen Parameter mitzugeben:

using UnityEngine;
public class Enemy : MonoBehaviour
{   
    [SerializeField] GameEvent<int> onDead;
    int points = 100;

    [ContextMenu(nameof(Die))]
    private void Die()
    {
        //Enemy is dead
        onDead.Raise( points );
    }
}

Und natürlich können wir jetzt auch verschiedene GameEvents zu erzeugen:

using UnityEngine;
[CreateAssetMenu(menuName = "GameEvents/Paramter: int", fileName = "IntGameEvent")]
public class IntGameEvent : GameEvent<int> { }

Dynamische Parameter mit ScriptableObject

8. Fazit - Events sind praktisch

Ob Du einzelne Events verwendest oder dir ein eigenes Eventsystem baust, musst Du im Einzelfall entscheiden.

Das obige Eventssytem ist nur ein Beispiel, man kann das auf verschiedene Weisen angehen. Auch ein eigenes EventSystem, welches Enums zur Unterscheidung der Events verwendet wäre denkbar. Egal wie, Events sind wirklich furchtbar hilfreich. Viel Erfolg bei deinen Projekten und bis bald!

Unity: Events in Unity Spielen verwenden