Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

[Unity / C#] Hashtable - Dokumentationskommentare und Parsing

  • 1
  • 2

Werbeanzeige

Renegade

Alter Hase

  • »Renegade« ist der Autor dieses Themas

Beiträge: 494

Wohnort: Berlin

Beruf: Certified Unity Developer

  • Private Nachricht senden

11

20.01.2014, 20:03

Das sieht schon mal sehr sehr interessant aus! Die Keys(des Hashtables) können aber auch in anderen Kontexten benutzt werden. Zum Beispiel anstelle eines GetKey auch bei GetButton(Wenn man den InputManager von Unity benutzen möchte, benötigt man diese).
Bedeutet das, dass ich dann verschiedene Dictionarys benötige?
Zur Verdeutlichung:

C#-Quelltext

 
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

    /// <summary>
    /// Register a Key with a specific Name
    /// </summary>
    /// <param name="target">GameObject where the SendMessage goes to</param>
    /// <param name="name">the specific Name of the Key (Use RegisterButton for Buttons via ProjectSettings Input!) </param>
    /// <param name="args">
    /// "down" - Callback Method Name for GetKeyDown
    /// "up" - Callback Method Name for GetKeyUp
    /// "auto" - Callback Method Name for GetKey
    /// </param>
    /// <returns>KeyData for Bookkeeping and DeRegistration</returns>
    public KeyData RegisterKey(GameObject target, string name, Hashtable args) {
        KeyData key = new KeyData(target, name, args);
        _keys.Add(key);
        return key;
    }
    /// <summary>
    /// Register a Button with a specific Name
    /// </summary>
    /// <param name="target">GameObject where the SendMessage goes to</param>
    /// <param name="name">the specific Name of the Button from ProjectSettings Input</param>
    /// <param name="args">
    /// "down" - Callback Method Name for GetButtonDown
    /// "up" - Callback Method Name for GetButtonUp
    /// "auto" - Callback Method Name for GetButton
    /// </param>
    /// <returns>ButtonData for Bookkeeping and DeRegistration</returns>
    public ButtonData RegisterButton(GameObject target, string name, Hashtable args) {
        ButtonData button = new ButtonData(target,name, args);
        _buttons.Add(button);
        return button;
    }


Zitat von »TrommlBomml«

Es kommt auf stark drauf an, was du in den If-statements tust, um dir sagen zu können, wie man das zusammenfassen kann.



Die Implementation einer if-Anweisung sieht momentan meist so oder ähnlich aus:

C#-Quelltext

 
1
2
3
4
5
6
7
8
9

if (key.args.ContainsKey("down")) {
    if (Input.GetKeyDown(key.code)) {
        if (key.args["down"] is string) {
            key.target.SendMessage(key.args["down"] as string, SendMessageOptions.RequireReceiver);
        } else {
            Debug.LogError("The value: " + key.args["down"] + " isn't a string!");
        }
    }
}


PS: Bist du am Wochenende auch beim GGJ?
Liebe Grüße,
René

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »Renegade« (20.01.2014, 20:14)

TrommlBomml

Community-Fossil

Beiträge: 2 117

Wohnort: Berlin

Beruf: Software-Entwickler

  • Private Nachricht senden

12

20.01.2014, 20:23

Dann könnte man vielleicht so reagieren (ungetestet):

C#-Quelltext

 
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

public void Update() 
{
    foreach (KeyData key in _keys) 
    {
        foreach(var keyNameAsString in key.args.Keys)
        {
            HandleKey(key, keyNameAsString, key.code != KeyCode.None);
        }
        if (IsInvalidKeyWithTarget(key)) 
        {
            Debug.LogError("The key: " + key.name + " with target: " + key.target + " has no callback methods!");
        }
    }
}

private bool IsInvalidKeyWithTarget(KeyData key)
{
    return key.args.ContainsKey("auto") == false && key.args.ContainsKey("down") == false && key.args.ContainsKey("up");
}

private void HandleKey(KeyData key, string keyName, bool hasKeycode)
{
    //todo: handle key without keycode.

    if (!Input.GetKeyDown(key.code)) return;
    
    if (key.args[keyName] is string) 
    {
        key.target.SendMessage(key.args[keyName] as string, SendMessageOptions.RequireReceiver);
    } 
    else 
    {
        Debug.LogError("The value: " + key.args["down"] + " isn't a string!");
    }
}


Das liest sich schonmal besser. Prinzipiell brauchst du dann eigene Dictionaries, oder du implementierst eine Generic-Klasse, mit einem generischen Typen für deine InputDaten (ButtonData, KeyData), und im Konstruktor ein Delegat zum Auswerten der Daten. Da muss ich aber wieder ein konkretes Beispiel sehen, was kommt herein, was soll geprüft werden.
Du kannst mit C# und delegaten verdammt gute Konstrukte entwerfen :)

Ich bin nicht bei der GGJ nicht dabei, WE habe ich meist anderes zu tun ;).

EDIT: Meine vermutung ist, je mehr Code du präsentierst, umso mehr wird sich die Lösung ändern. kann man sich das im Zusammenhang als C#-Projekt mal anschauen? Ich würde es auch vertraulich behandeln.
  • 1
  • 2

Ähnliche Themen