Boucles et tableaux | Documentation

Tableaux peuvent être combinés avec des boucles, telles que while et for, pour répéter le même code pour chaque valeur indexée. Par exemple, téléporter chaque joueur dans un tableau vers un nouvel endroit ou faire en sorte qu'un tableau de pièces prenne feu.

Pour explorer le parcours de tableaux, créez un chemin de pont qui disparaît où des pièces sont placées dans un tableau et se font disparaître une par une.

Parcourir un tableau

Pour le projet, trouvez ou créez un ensemble de trois pièces à faire disparaître. Les pièces doivent toutes être ancrées.

Créez trois pièces. Nommez les pièces dans l'ordre dans lequel elles devraient disparaître, Partie1, Partie2, Partie3.
Dans ServerScriptService, insérez un nouveau script et créez un tableau pour stocker les pièces.
```
local pathArray = {
}
```

Sur une seule ligne chacune, tapez le nom des pièces dans l'ordre dans lequel elles devraient disparaître. Utiliser une nouvelle ligne pour chaque valeur rend la lecture plus facile.


local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

Utiliser une boucle for avec un tableau

Utilisez une boucle for pour parcourir le tableau et contrôler la vitesse à laquelle les pièces devraient disparaître dans l'ordre où les pièces sont indexées dans le tableau.

Pour contrôler à quelle fréquence une pièce disparaît en secondes, créez une variable nommée VANISH_RATE. Pour les tests, il est préférable de la maintenir à un petit nombre.
```
local VANISH_RATE = 1.5

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3
}
```
Constantes sont des variables qui ne devraient pas être modifiées par un autre code dans le script. Elles auront probablement besoin d'être ajustées et sont placées en haut du script en ALL_CAPS pour les rendre faciles à repérer.
Créez une boucle for avec les indications suivantes : Début : partIndex = 1, l'index de la première valeur dans le tableau. Fin : #pathArray, la taille de ce tableau.
```
for partIndex = 1, #pathArray  do

end
```

Pour qu'il y ait un délai avant qu'une pièce disparaisse, dans la boucle, ajoutez un task.wait() en utilisant VANISH_RATE.


for partIndex = 1, #pathArray  do
   task.wait(VANISH_RATE)
end

Pour faire disparaître une pièce, créez une nouvelle variable nommée whichPart et définissez-la égale à partsArray[partIndex]. Ensuite, pour faire disparaître cette pièce, définissez sa propriété CanCollide sur false et Transparency sur 1.


for partIndex = 1, #pathArray  do
   task.wait(VANISH_RATE)
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = false
   whichPart.Transparency = 1
end

Vérifiez que les pièces du chemin disparaissent au fil du temps.

Conseils de dépannage

Si le pont ne disparaît pas, vérifiez les problèmes possibles ci-dessous :

Problème : Les pièces disparaissent trop vite ou sont toutes disparues dès le départ.

En fonction de la rapidité avec laquelle votre personnage se charge dans l'expérience, les premières pièces peuvent déjà être invisibles. Pour y remédier, ajoutez une petite attente, comme task.wait(2), au début du script.

Codez la deuxième boucle

Pour l'instant, les pièces disparaissent indéfiniment. Pour les faire réapparaître, créez une deuxième boucle for qui parcourra chaque pièce et rendra chaque élément de nouveau praticable.

Après la première boucle, ajoutez un task.wait() pour créer un court délai avant que le chemin réapparaisse.


for partIndex = 1, #pathArray  do
	task.wait(VANISH_RATE)
	local whichPart = pathArray[partIndex]
	whichPart.CanCollide = false
	whichPart.Transparency = 1
end

task.wait(1)

De votre propre initiative, essayez de coder une deuxième boucle for qui rend le chemin de nouveau utilisable en changeant la propriété CanCollide de chaque pièce sur true et Transparency sur 0. Une fois terminé, vérifiez votre travail par rapport au code ci-dessous.


-- Réinitialisez le chemin en rendant toutes les pièces de nouveau praticables
for partIndex = 1, #pathArray do
   local whichPart = pathArray[partIndex]
   whichPart.CanCollide = true
   whichPart.Transparency = 0
end

Les pièces non ancrées tomberont à travers la base lorsque CanCollide est false. Si les pièces ne réapparaissent pas, et qu'il n'y a pas d'erreurs dans la sortie, ancrez les pièces et testez à nouveau.

Testez le projet pour confirmer qu'une fois que toutes les pièces disparaissent, elles reviennent.

Répéter avec une boucle while

Les pièces disparaissent et réapparaissent, mais seulement une fois. Pour que le code continue de se répéter, imbriquez tout le code dans une boucle while.

En bas du script, créez une nouvelle boucle while true do. Ensuite, déplacez les deux boucles for dans la boucle while.


while true do
   -- Faites disparaître une pièce du tableau dans l'ordre
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Attendez une seconde avant de faire réapparaître le chemin
	task.wait(1)

	-- Réinitialisez le chemin en rendant toutes les pièces de nouveau praticables
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Vérifiez qu'une fois que toutes les pièces disparaissent, elles réapparaissent.

Une version terminée du projet peut être téléchargée.

Script complété
local VANISH_RATE = 1.0

local pathArray = {
	workspace.Part1,
	workspace.Part2,
	workspace.Part3,
}

while true do
	-- Faites disparaître une pièce du tableau dans l'ordre
	for partIndex = 1, #pathArray  do
		task.wait(VANISH_RATE)
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = false
		whichPart.Transparency = 1
	end

	-- Attendez une seconde avant de faire réapparaître le chemin
	task.wait(1.0)

	-- Réinitialisez le chemin en rendant toutes les pièces de nouveau praticables
	for partIndex = 1, #pathArray do
		local whichPart = pathArray[partIndex]
		whichPart.CanCollide = true
		whichPart.Transparency = 0
	end
end

Tableaux et ipairs()

ipairs() est utilisé avec tableaux. Le "i" dans ipairs() signifie "index". ipairs() peut être utilisé pour répéter rapidement une opération sur un grand nombre d'objets, comme, disons, un dossier plein de pièces.

Cela sera démontré en ajoutant rapidement des particules à un dossier entier de pièces.

Dans Workspace, créez un dossier nommé PartsFolder. Ajoutez autant de pièces que vous le souhaitez.
Dans ServerScriptService, créez un nouveau script et référencez le dossier.

Utilisez GetChildren() pour obtenir automatiquement un tableau listant tous les objets dans le dossier.


local partsFolder = workspace.PartsFolder

-- Obtient un tableau listant les pièces dans PartsFolder
local partsArray = partsFolder:GetChildren()

Utilisez in ipairs(ArrayToUse) avec la boucle for pour parcourir partsArray et ajouter des particules.

Script complété
-- Obtient un tableau listant les pièces dans PartsFolder
local partsArray = partsFolder:GetChildren()

-- Ajoute des particules à chaque pièce du tableau
for index, part in ipairs(partsArray) do
	local particles = Instance.new("ParticleEmitter")
	particles.Parent = part
end

Testez et regardez les particules flotter depuis chaque pièce dans le dossier.

Résumé

Les boucles peuvent être combinées avec des tableaux pour travailler rapidement avec un nombre quelconque de valeurs. Si vous souhaitez avoir un contrôle exact sur ce qui arrive à quelques pièces et dans quel ordre, un tableau doit être codé en dur avec des valeurs spécifiques.

Pour travailler avec de nombreuses pièces où l'ordre n'a pas d'importance, GetChildren() peut créer un tableau des enfants d'un objet. En utilisant ipairs(), la liste peut être parcourue rapidement sans connaître la taille du tableau.