Unity List – Guide

Unity List vs. Array

La principale distinction entre une liste et un tableau réside dans le fait qu’un tableau a un nombre fixe d’éléments définis à l’instantiation, tandis qu’une liste possède un nombre dynamique d’éléments qui s’ajuste en fonction des ajouts.

Je ne veux pas entrer dans trop de détails sur toutes les différences, mais pour plus d’informations, vous pouvez consulter cet article.

Travailler avec les listes

Les listes fonctionnent de manière similaire aux tableaux ; vous devez définir le type d’éléments qu’elles stockeront.

using System.Collections.Generic;
using UnityEngine;

public class ListMono : MonoBehaviour
{
    public List<int> nombres = new List<int>();


    private void CreerListe()
    {
        var listNombres = new List<int>() { 5, 2, 3 };
    }
}
            

Liste de GameObjects

Utiliser une liste avec des GameObjects dans l’inspecteur

Sur Unity, vous pouvez ajouter une liste de GameObjects, tout comme les tableaux, ils peuvent contenir des éléments de n’importe quel type.
De plus, Unity peut sérialiser les listes, garantissant une bonne intégration.

Commencez par créer un monobehaviour avec un champ « List<GameObject> » comme ceci :

public class MonComportement : MonoBehaviour 
{
    public List<GameObject> gameObjects = new List<GameObject>();
}

Ensuite, attribuez votre monobehaviour à un gameObject dans votre scène.

Sélectionnez-le, puis verrouillez-le via le cadenas en haut à droite de l’inspecteur.
Sélectionnez ensuite les gameObjects que vous souhaitez ajouter provenant de votre scène ou étant un prefab.

Vous pouvez utiliser le raccourci « SHIFT » pour une sélection multiple, ou « CTRL » pour ajouter un élément à votre sélection.
Pour finir, faites glisser et déposez vos éléments dans le champ de liste de l’inspecteur.

Placer des GameObjects dans une liste

Pour ajouter des GameObjects à une liste, récupérez d’abord les gameObjects que vous souhaitez ajouter, puis ajoutez-les à la liste à l’aide de la fonction « Add ».

Pour notre exemple, nous utiliserons Instantiate sur un prefab et stockerons les GameObjects invoqués dans notre liste de la manière suivante :

	private List<GameObject> _gameObjects = new List<GameObject>();

	public GameObject prefab;

	private void Invoke()
	{
		for (int i = 0; i < 10; i++)
		{
			_gameObjects.Add(Instantiate(prefab));
		}
	}

Nous pouvons ensuite utiliser notre liste de GameObjects pour d’autres actions.

FAQ

Comment obtenir une liste de tous les GameObjects dans Unity ?

Pour obtenir une liste de tous les GameObjects présents dans la scène, vous pouvez utiliser : Object.FindObjectsByType(FindObjectsSortMode.None);

Par défaut, les GameObjects inactifs ne sont pas récupérés.
Ajoutez le premier paramètre « FindObjectsInactive.Include » pour les récupérer.

Cette fonction renvoie un tableau de GameObjects.

Comment obtenir un objet à partir d’une liste dans Unity ?

Pour récupérer un objet d’une liste, nous pouvons utiliser la méthode « Find » sur la liste, qui prend une fonction prédicat comme paramètre pour appliquer une condition.

Par exemple, si vous voulez récupérer le gameObject avec un tag spécifique : var gameObject = myList.Find(x => x.CompareTag("Player"));

Si vous voulez récupérer tous les éléments correspondant à votre condition, vous pouvez utiliser « FindAll« .

Boucler à travers une liste

La liste hérite de IEnumerable, permettant l’itération avec les constructions « for, » « foreach, » et autres.

using System.Collections.Generic;

private void Boucle()
{
    var listNombres = new List<int>() { 5, 2, 3 };

    for (int i = 0; i < listNombres.Count; i++)
    {
        var nombre = listNombres[i];
    }

    foreach (var nombre in listNombres)
    {

    }
    
    // Personnellement, je n'utilise que celui-ci avec des événements
    listNombres.ForEach((nombre) => {
        // faire quelque chose
    });
}
            

Ajouter à la liste

Pour ajouter un élément à une liste, la fonction Add est utilisée.

using System.Collections.Generic;

private void Ajouter()
{
    var listNombres = new List<int>();
    listNombres.Add(5);
}
            

Longueur / Comptage de la liste

Pour récupérer le nombre d’éléments dans une liste, la propriété Count est utilisée.
Lire l’article complet sur : Longueur de liste.

using System.Collections.Generic;

public List<GameObject> gameObjects = new List<GameObject>();

private void Compter()
{
    int count = gameObjects.Count;
}
            

Retirer de la liste

Pour supprimer un élément d’une liste, la fonction Remove est utilisée.

Lire l’article complet sur : Suppression d’un élément d’une liste.

using System.Collections.Generic;

private void Retirer()
{
    var listNombres = new List<int>() { 5, 2, 3 };

    if (listNombres.Remove(3))
    {
        // 3 est trouvé et retiré de la liste
        // listNombres ne contient plus que 5, 2 maintenant
    }
}
            

Retirer à l’indice de la liste

Pour supprimer un élément par indice, la fonction RemoveAt est utilisée. Elle est généralement plus rapide que la suppression par élément.

using System.Collections.Generic;

private void RetirerAIndice()
{
    var listNombres = new List<int>() { 5, 2, 3 };

    listNombres.RemoveAt(1);
    // listNombres ne contient plus que 5, 3 maintenant
}
            

Trouver dans la liste

Pour trouver un élément, vous pouvez boucler et trouver l’élément avec une condition ou utiliser la fonction Find.

using System.Collections.Generic;

public List<GameObject> gameObjects = new List<GameObject>();

private GameObject TrouverParInstanceId(int instanceId)
{
    foreach (var gameObj in gameObjects)
    {
        if (gameObj.GetInstanceID() == instanceId)
        {
            return gameObj;
        }
    }

    return null;
}

private GameObject TrouverParInstanceIdFind(int instanceId)
{
    return gameObjects.Find(x => x.GetInstanceID() == instanceId);
}
            

Vérifier si la liste contient

Pour vérifier si un élément existe, vous pouvez boucler ou utiliser la fonction Contains.

using System.Collections.Generic;

public List<GameObject> gameObjects = new List<GameObject>();

private bool Contient()
{
    // Nous sommes dans un MonoBehaviour, vérifiant si le gameObject actuel est dans la liste
    return gameObjects.Contains(gameObject);
}
            

Trier la liste

Pour trier les éléments, vous pouvez utiliser la méthode Sort. Sans arguments, elle trie par ordre croissant.

using System.Collections.Generic;

private void Trier()
{
    // Tri ascendant
    var listNombres = new List<int>() { 5, 2, 3 };
    listNombres.Sort();

    // Tri descendant
    listNombres.Sort((a, b) => b.CompareTo(a));
}
            

Note : Si vous devez effectuer des actions sur une liste dans l’ordre croissant, puis dans l’ordre décroissant, il peut être intéressant de trier la liste puis d’utiliser Reverse.

Vous pouvez également trier des listes plus complexes :

using System.Collections.Generic;
using System.Linq;

public List<GameObject> gameObjects = new List<GameObject>();

private void TrierGameObjectParNom()
{
    // Asc
    gameObjects.Sort((a, b) => a.name.CompareTo(b.name));

    // Desc
    gameObjects.Sort((a, b) => b.name.CompareTo(a.name));
}

// Ou utilisez LINQ :
// Asc
gameObjects = gameObjects.OrderBy(x => x.name).ToList();

// Desc
gameObjects = gameObjects.OrderByDescending(x => x.name).ToList();
            

Effacer la liste

Pour vider une liste, utilisez la fonction Clear.

using System.Collections.Generic;

private void Vider()
{
    // Tri ascendant
    var listNombres = new List<int>() { 5, 2, 3 };
    listNombres.Clear();
}