unity3d
Tags

Introduktion

Skapa och tillämpa taggar

Taggar används vanligtvis via redigeraren; Du kan dock också använda taggar via skript. Alla anpassade taggar måste skapas via fönstret Taggar & lager innan de appliceras på ett spelobjekt.

Ställa in taggar i redigeraren

Med ett eller flera spelobjekt markerade kan du välja en tagg från inspektören. Spelobjekt kommer alltid att ha en enda tagg; som standard kommer spelobjekt att märkas som "Ej taggat" . Du kan också flytta till fönstret Taggar & lager genom att välja "Lägg till tagg ..." ; Det är dock viktigt att notera att detta bara tar dig till fönstret Taggar & lager . Alla taggar du skapar kommer inte automatiskt att gälla för spelobjektet.

Ställa in taggar via skript

Du kan direkt ändra en spelobjekttagg via kod. Det är viktigt att notera att du måste ange en tagg från listan med aktuella taggar; om du anger en tagg som inte redan har skapats kommer detta att resultera i ett fel.

Såsom beskrivs i andra exempel kan användning av en serie static string strängvariabler i motsats till att manuellt skriva varje tagg garantera konsistens och tillförlitlighet.

Följande skript visar hur vi kan ändra en serie taggar med static string hjälp av static string att säkerställa konsekvens. Observera antagandet att varje static string representerar en tagg som redan har skapats i fönstret Taggar & lager .

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;
        }
    }
}

Skapa anpassade taggar

Oavsett om du ställer taggar via inspektören eller via skript måste taggar deklareras via fönstret Taggar & lager före användning. Du kan komma åt det här fönstret genom att välja "Lägg till taggar ..." från en rullgardinsmeny för ett spelobjekt. Alternativt kan du hitta fönstret under Redigera> Projektinställningar> Taggar och lager .

Välj bara + -knappen, ange önskat namn och välj Spara för att skapa en tagg. Om du väljer - knappen tas den markerade taggen bort. Observera att taggen på detta sätt omedelbart visas som "(Borttagen)" och kommer att tas bort helt när projektet åter laddas.

Om du väljer växel / kugge längst upp till höger i fönstret kan du återställa alla anpassade alternativ. Detta tar omedelbart bort alla anpassade taggar, tillsammans med alla anpassade lager du kan ha under "Sortera lager" och "Lager" .

Hitta GameObjects efter tagg:

Taggar gör det särskilt lätt att hitta specifika spelobjekt. Vi kan leta efter ett enda spelobjekt eller leta efter flera.

Hitta ett enda GameObject

Vi kan använda den statiska funktionen GameObject.FindGameObjectWithTag(string tag) att leta efter enskilda spelobjekt. Det är viktigt att notera att på detta sätt spelobjekten inte fråges i någon särskild ordning. Om du söker efter en tagg som används på flera spelobjekt i scenen kan denna funktion inte garantera vilket spelobjekt som returneras. Som sådan är det mer lämpligt när vi vet att endast ett spelobjekt använder en sådan tagg, eller när vi inte är oroliga för exakt GameObject av GameObject som returneras.

///<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);

Hitta en GameObject av GameObject instanser

Vi kan använda den statiska funktionen GameObject.FindGameObjectsWithTag(string tag) att leta efter alla spelobjekt som använder en viss tagg. Detta är användbart när vi vill iterera genom en grupp specifika spelobjekt. Detta kan också vara användbart om vi vill hitta ett enda spelobjekt, men kan ha flera spelobjekt med samma tagg. Eftersom vi inte kan garantera den exakta instansen som returneras av GameObject.FindGameObjectWithTag(string tag) , måste vi istället hämta en matris med alla potentiella GameObject instanser med GameObject.FindGameObjectsWithTag(string tag) och analysera den resulterande matrisen ytterligare för att hitta den instans vi är letar efter.

///<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.)
}

Jämföra taggar

Vid jämförelse av två GameObjects med taggar bör det noteras att följande skulle orsaka Garbage Collector omkostnader eftersom en sträng skapas varje gång:

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

När du gör dessa jämförelser inom Update () och annan vanlig Unitys återuppringning (eller en loop), bör du använda den här metoden för tilldelning av heap:

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

Dessutom är det lättare att hålla dina taggar i en statisk klass.

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

Då kan du jämföra säkert

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

på detta sätt genereras dina taggsträngar vid sammanställningstid och du begränsar följderna av stavfel.

Precis som att hålla taggar i en statisk klass är det också möjligt att lagra dem i en uppräkning:

public enum Tags
{
    Player, Ennemies, MyCustomTag;
}

och sedan kan du jämföra det med metoden toString() :

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