unity3d
Tags

Invoering

Tags maken en toepassen

Tags worden meestal toegepast via de editor; u kunt echter ook tags toepassen via een script. Elke aangepaste tag moet worden gemaakt via het venster Tags en lagen voordat deze op een game-object wordt toegepast.

Tags instellen in de Editor

Met een of meer spelobjecten geselecteerd, kunt u een tag van de infovenster selecteren. Spelobjecten hebben altijd één tag; spelobjecten worden standaard getagd als "Niet getagd " . U kunt ook naar het venster Tags & lagen gaan door "Tag toevoegen ..." te selecteren ; het is echter belangrijk op te merken dat u hiermee alleen naar het venster Tags & lagen gaat . Elke tag die je maakt, wordt niet automatisch toegepast op het game-object.

Tags instellen via script

Je kunt een tag voor game-objecten direct wijzigen via code. Het is belangrijk op te merken dat u een label uit de lijst van de huidige labels moeten bieden; als u een tag opgeeft die nog niet is gemaakt, leidt dit tot een fout.

Zoals in andere voorbeelden wordt beschreven, kan het gebruik van een reeks static string in plaats van het handmatig schrijven van elke tag zorgen voor consistentie en betrouwbaarheid.

Het volgende script laat zien hoe we een reeks tags van static string kunnen wijzigen, met behulp van static string om consistentie te garanderen. Let op de veronderstelling dat elke static string een tag vertegenwoordigt die al is gemaakt in het venster Tags en lagen .

using UnityEngine;

public class Tagging : MonoBehaviour
{
    static string tagUntagged = "Untagged";
    static string tagPlayer = "Player";
    static string tagEnemy = "Enemy";

    /// <summary>Represents the player character. This game object should 
    /// be linked up via the inspector.</summary>
    public GameObject player;
    /// <summary>Represents all the enemy characters. All enemies should 
    /// be added to the array via the inspector.</summary>
    public GameObject[] enemy;

    void Start ()
    {
        // We ensure that the game object this script is attached to
        // is left untagged by using the default "Untagged" tag.
        gameObject.tag = tagUntagged;

        // We ensure the player has the player tag.
        player.tag = tagUntagged;

        // We loop through the enemy array to ensure they are all tagged.
        for(int i = 0; i < enemy.Length; i++)
        {
            enemy[i].tag = tagEnemy;
        }
    }
}

Aangepaste tags maken

Ongeacht of u tags instelt via de Inspector of via een script, tags moeten vóór gebruik worden aangegeven via het venster Tags & lagen . Je kunt dit venster openen door "Tags toevoegen ..." te selecteren in het vervolgkeuzemenu van een tag met gameobjecten. Als alternatief kunt u het venster vinden onder Bewerken> Projectinstellingen> Tags en lagen .

Selecteer eenvoudig de + knop, voer de gewenste naam in en selecteer Opslaan om een tag te maken. Als u de knop - selecteert, wordt de gemarkeerde tag verwijderd. Merk op dat op deze manier de tag onmiddellijk wordt weergegeven als "(Verwijderd)" en volledig wordt verwijderd wanneer het project de volgende keer opnieuw wordt geladen.

Als u het tandwiel / tandwiel rechtsboven in het venster selecteert, kunt u alle aangepaste opties opnieuw instellen. Hiermee worden onmiddellijk alle aangepaste tags verwijderd, samen met elke aangepaste laag die u mogelijk hebt onder "Lagen sorteren" en "Lagen" .

GameObjects zoeken op tag:

Tags maken het bijzonder eenvoudig om specifieke game-objecten te vinden. We kunnen zoeken naar een enkel spelobject of zoeken naar meerdere.

Een enkel GameObject

We kunnen de statische functie GameObject.FindGameObjectWithTag(string tag) om naar afzonderlijke GameObject.FindGameObjectWithTag(string tag) te zoeken. Het is belangrijk op te merken dat op deze manier spelobjecten niet in een bepaalde volgorde worden opgevraagd. Als u naar een tag zoekt die op meerdere spelobjecten in de scène wordt gebruikt, kan deze functie niet garanderen welk spelobject wordt geretourneerd. Als zodanig is het geschikter als we weten dat slechts één game-object een dergelijke tag gebruikt, of als we ons geen zorgen maken over de exacte instantie van GameObject die wordt geretourneerd.

///<summary>We create a static string to allow us consistency.</summary>
string playerTag = "Player"

///<summary>We can now use the tag to reference our player GameObject.</summary>
GameObject player = GameObject.FindGameObjectWithTag(playerTag);

Een array met GameObject instanties zoeken

We kunnen de statische functie GameObject.FindGameObjectsWithTag(string tag) om te zoeken naar alle GameObject.FindGameObjectsWithTag(string tag) die een bepaalde tag gebruiken. Dit is handig als we een groep specifieke spelobjecten willen doorlopen. Dit kan ook handig zijn als we één spelobject willen vinden, maar mogelijk meerdere spelobjecten hebben met dezelfde tag. Omdat we niet kunnen garanderen dat de exacte instantie wordt geretourneerd door GameObject.FindGameObjectWithTag(string tag) , moeten we in plaats daarvan een array ophalen van alle mogelijke GameObject instanties met GameObject.FindGameObjectsWithTag(string tag) en de resulterende array verder analyseren om de instantie te vinden die we zijn zoeken naar.

///<summary>We create a static string to allow us consistency.</summary>
string enemyTag = "Enemy";

///<summary>We can now use the tag to create an array of all enemy GameObjects.</summary>
GameObject[] enemies = GameObject.FindGameObjectsWithTag(enemyTag );

// We can now freely iterate through our array of enemies
foreach(GameObject enemy in enemies)
{
    // Do something to each enemy (link up a reference, check for damage, etc.)
}

Tags vergelijken

Bij het vergelijken van twee GameObjects op tags, moet worden opgemerkt dat het volgende Garbage Collector overhead zou veroorzaken omdat elke keer een string wordt gemaakt:

if (go.Tag == "myTag")
{ 
    //Stuff 
}

Wanneer u deze vergelijkingen uitvoert in Update () en andere callback van Unity (of een lus), moet u deze heap-toewijzingsmethode gebruiken:

if (go.CompareTag("myTag")
{ 
    //Stuff 
}

Bovendien is het eenvoudiger om uw tags in een statische klasse te houden.

public static class Tags
{
    public const string Player = "Player";
    public const string MyCustomTag = "MyCustomTag";
}

Dan kun je veilig vergelijken

if (go.CompareTag(Tags.MyCustomTag)
{ 
    //Stuff 
}

Op deze manier worden uw tagreeksen tijdens het compileren gegenereerd en beperkt u de implicaties van spelfouten.

Net als het houden van tags in een statische klasse, is het ook mogelijk om het in een opsomming op te slaan:

public enum Tags
{
    Player, Ennemies, MyCustomTag;
}

en dan kun je het vergelijken met de methode enum toString() :

if (go.CompareTag(Tags.MyCustomTag.toString())
{ 
    //Stuff 
}