Unity new UI - Ändert dynamisch die Funktionen, die von GUI-Elementen aufgerufen werden

Suchen Sie den Wert in der Schaltfläche OnClick und Schieberegler On Value Changed dynamisch zu ändern .

Wenn ich raten musste, wie das gemacht wurde, besorge ich mir einen Verweis auf das button / gui-Element. Rufen Sie als Nächstes die Button-Skriptkomponente auf und greifen Sie auf diese Liste von Funktionsaufrufen zu. Ich bin mir jedoch nicht sicher, wie ich diese Liste ändern soll. Hat jemand irgendwelche Ideen?

Weitere Details, die helfen könnten:

• Die aufgerufene Funktion gehört nicht zu einer benutzerdefinierten Skriptkomponente
• Verwenden Sie die Variable 'dynamic' für die Schieberegler
• Könnte verwendet werden, um dynamische Schaltflächen zu erstellen

Es gibt eine sehr einfache Möglichkeit, Ereignisse zu ändern:

BEARBEITEN

In meiner anderen Antwort finden Sie die schnelle und einfache Möglichkeit, ein Ereignis nur für das OnClickEreignis hinzuzufügen . Für andere Veranstaltungen OnDragsiehe unten.

Wenn Sie mehr als nur die standardmäßig bereitgestellten Ereignisse benötigen, würde ich empfehlen, stattdessen ein EventTriggeran Ihr Spielobjekt anzuhängen. Dies gibt uns Zugriff auf das BaseEventDataObjekt, das vom Ereignis zurückgegeben wurde, und teilt uns Dinge wie das Objekt mit, das das Ereignis erstellt hat. Dann können Sie etwas tun wie:

//Create an event delegate that will be used for creating methods that respond to events
public delegate void EventDelegate(UnityEngine.EventSystems.BaseEventData baseEvent);

Dann können wir eine Methode zur Behandlung von Ereignissen erstellen. Die Signatur muss mit der unseres Delegierten übereinstimmen. Daher muss es als ersten und einzigen Parameter zurückgeben voidund akzeptieren BaseEventData:

public void DropEventMethod(UnityEngine.EventSystems.BaseEventData baseEvent) {
    Debug.Log(baseEvent.selectedObject.name + " triggered an event!");
    //baseEvent.selectedObject is the GameObject that triggered the event,
    // so we can access its components, destroy it, or do whatever.
}

Zum Schluss, um das Ereignis dynamisch hinzuzufügen:

//Get the event trigger attached to the UI object
EventTrigger eventTrigger = buttonObject.GetComponent<EventTrigger>();

//Create a new entry. This entry will describe the kind of event we're looking for
// and how to respond to it
EventTrigger.Entry entry = new EventTrigger.Entry();

//This event will respond to a drop event
entry.eventID = EventTriggerType.Drop;

//Create a new trigger to hold our callback methods
entry.callback = new EventTrigger.TriggerEvent();

//Create a new UnityAction, it contains our DropEventMethod delegate to respond to events
UnityEngine.Events.UnityAction<BaseEventData> callback =
    new UnityEngine.Events.UnityAction<BaseEventData>(DropEventMethod);

//Add our callback to the listeners
entry.callback.AddListener(callback);

//Add the EventTrigger entry to the event trigger component
eventTrigger.delegates.Add(entry);

Wenn Sie Version 5.3.3 oder höher verwenden, verwenden Sie diese Zeile anstelle der letzten Zeile oben. Delegaten werden abgeschrieben :

eventTrigger.triggers.Add(entry); 

Das Wort ist, dass die delegate{}in meiner vorherigen Antwort gefundene Syntax veraltet ist. Es gibt eine andere Möglichkeit, dies mit der Lambda-Notation zu tun:

void buttonSetup(Button button) {
    //Remove the existing events
    button.onClick.RemoveAllListeners();
    //Add your new event using lambda notation
    button.onClick.AddListener (handleButton);
}

void handleButton() {
    Debug.Log("Button pressed!");
}

Oder Sie können den Button weitergeben, um die Dinge etwas dynamischer zu gestalten:

void buttonSetup(Button button) {
    button.onClick.RemoveAllListeners();
    //Add your new event
    button.onClick.AddListener(() => handleButton(button));
}

void handleButton(Button b) {
    Debug.Log("Button '" + b.name + "' pressed!");
}

Erstellen Sie ein neues Skript wie folgt:

public class EventHandler : MonoBehaviour, IPointerClickHandler
{
    public void OnPointerClick(PointerEventData eventData)
    {
        Debug.Log("Element: " +
                   eventData.selectedObject.name +
                   " was clicked at " +
                   eventData.position.ToString());
    }
}

Dieses Skript implementiert in der Schnittstelle IPointerClickHandler (neben vielen anderen verfügbaren Schnittstellen ). Durch einfaches Anhängen dieses Skripts an ein UI-Element kann dieses Skript Klickereignisse abfangen (oder für welches Ereignis Sie die Schnittstelle implementieren).

Der nächste Schritt besteht darin, dieses Skript einfach dynamisch als Komponente zum gewünschten UI-Element hinzuzufügen:

myButton.AddComponent<EventHandler>();

Dadurch wird das Skript als Komponente hinzugefügt, myButtonund wenn ich das nächste Mal auf die Schaltfläche klicke, erhalte ich Informationen darüber, auf welche Schaltfläche geklickt wurde und wo der Klick stattgefunden hat.

Dies bietet die meisten Informationen über das Ereignis im Vergleich zu meinen anderen Antworten.

Die Implementierung der Benutzeroberfläche durch Unity erfolgt wie bei allen anderen Unity-Komponenten. Sie fügen GameObject hinzu und fügen UI-Komponenten hinzu. Sobald Sie das Spielobjekt haben, können Sie die UI-Komponenten daraus abrufen und die Eigenschaften ändern.

Die API-Referenz für die Benutzeroberfläche befindet sich im UnityEngine.UI-Namespace. Die API-Referenz für BUtton lautet http://docs.unity3d.com/ScriptReference/UI.Button.html

Weitere Informationen zum Zugriff auf die Benutzeroberfläche über C # -Skripte finden Sie im Beitrag http://blog.trsquarelab.com/2015/03/new-ui-implementation-using-c-scripts.html