Tableau

Lorsque vous avez des variables du même type, vous pouvez les rassembler dans une matrice. Une matrice est un type de conteneur où vous spécifiez le type des éléments avec []type, comme []float. Une matrice est utile, car elle s'adapte au nombre d'éléments que vous y stockez sans modifier votre code d'accès aux éléments.

Par exemple, si vous avez plusieurs joueurs dans votre jeu, vous pouvez créer une matrice et l’initialiser avec tous les joueurs.

Players : []player = array{Player1, Player2}

Verse présente le modèle où la définition reflète l'utilisation. La définition d'une matrice et son utilisation suivent ce modèle.

Longueur de la matrice

Vous pouvez obtenir le nombre d'éléments dans une matrice en accédant au membre Length de la matrice. Par exemple, array{10, 20, 30}.Length renvoie 3.

Accès aux éléments d’une matrice

Les éléments d'une matrice sont ordonnés dans le même ordre que celui dans lequel ils ont été insérés, et vous pouvez accéder à l'élément à cette position, appelée son index, dans la matrice. Par exemple, pour obtenir le premier joueur, vous accédez à la matrice Players avec Players[0].

Le premier élément d'une matrice a un index de 0 et l'index de chaque élément suivant augmente en nombre. Par exemple, array{10, 20, 30}[0] correspond à 10 et array{10, 20, 30}[1] correspond à 20.

Le dernier index d'une matrice est inférieur d'une unité à la longueur de la matrice. Par exemple, array{10, 20, 30}.Length est égal à 3 et l'index de 30 dans array{10, 20, 30} est 2.

L'accès à un élément d'une matrice est une expression faillible et ne peut être utilisé que dans un contexte d'échec, comme une expression if. Par exemple :

ExampleArray : []int = array{10, 20, 30, 40, 50}
for (Index := 0..ExampleArray.Length - 1):
    if (Element := ExampleArray[Index]):
        Print("{Element} in ExampleArray at index {Index}")

Ce code s'imprimera :

10 in ExampleArray at index 0
    20 in ExampleArray at index 1
    30 in ExampleArray at index 2
    40 in ExampleArray at index 3
    50 in ExampleArray at index 4

Modifier une matrice et ses éléments

Les matrices, comme toutes les autres valeurs dans Verse, sont immuables. Si vous définissez une variable de matrice, cela vous permet d'affecter une nouvelle matrice à la variable ou de modifier des éléments individuels.

Par exemple :

# Array1 is an array of integers
Array1 : []int = array{10, 11, 12}

# Array2 is an array variable of integers
var Array2 : []int = array{20, 21, 22}

# we concatenate Array1, Array2, and a new array of integers
# and assign that to the Array2 variable
set Array2 = Array1 + Array2 + array{30, 31}

Ce code s'imprimera :

10 at index 0
    77 at index 1
    12 at index 2
    20 at index 3
    21 at index 4
    22 at index 5
    30 at index 6
    31 at index 7

Matrices multidimensionnelles

Les matrices des exemples précédents étaient toutes unidimensionnelles, mais vous pouvez également créer des matrices multidimensionnelles. Les matrices multidimensionnels ont une autre matrice, ou plusieurs matrices, stockées dans chaque index, comme les colonnes et les lignes d'un tableau.

Par exemple, le code suivant produit une matrice bidimensionnelle (2D), visualisée dans le tableau suivant :

var Counter : int = 0
Example : [][]int =
    for (Row := 0..3):
        for(Column := 0..2):
            set Counter += 1

Pour accéder aux éléments d'une matrice 2D, vous devez utiliser deux index. Par exemple, Example[0][0] correspond à 1, Example[0][1] correspond à 2, et Example[1][0] correspond à 4.

Le code suivant expliquer comment utiliser une expression for pour itérer dans la matrice 2D Example.

if (NumberOfColumns : int = Example[0].Length):
    for(Row := 0..Example.Length-1, Column := 0..NumberOfColumns):
         if (Element := Example[Row][Column]):
             Print("{Element} at index [{Row}][{Column}]")

Ce code s'imprimera :

1 at index [0][0]
    2 at index [0][1]
    3 at index [0][2]
    4 at index [1][0]
    5 at index [1][1]
    6 at index [1][2]
    7 at index [2][0]
    8 at index [2][1]
    9 at index [2][2]
    10 at index [3][0]

Il n'est pas nécessaire que le nombre de colonnes dans chaque ligne soit constant.

Par exemple, le code suivant produit une matrice bidimensionnelle (2D), visualisée dans le tableau suivant, où le nombre de colonnes de chaque ligne est supérieur à celui de la ligne précédente :

Example : [][]int =
    for (Row := 0..3):
        for(Column := 0..Row):
            Row * Column

Type persistant

Une matrice est persistance si les éléments qu'elle comporte sont de type persistant. Autrement dit, vous pouvez les utiliser dans vos variables weak_map sur l'étendue du module et faire persister leurs valeurs d'une session de jeu à l'autre. Pour en savoir plus sur la persistance dans Verse, consultez la page Utiliser des données persistantes dans Verse.