Bienvenue dans les scripts intermédiaires ! Si vous ne l'avez pas déjà fait, veuillez consulter le guide du débutant sur les scripts. Ce tutoriel de script vous apprendra comment scripter à un niveau intermédiaire, tout d'abord, comme bien sûr il y a avec tous les autres tutoriels de script, il y a -bien- plus que quelques concepts que vous devez avoir appris en premier - événements, méthodes, tables, des boucles, des instructions "if", des instructions "else" et des instructions "elseif".
Contenu
- 1 Juste un examen rapide
- 2 Déclarations Si
- 2.1 Opérateurs relationnels
- 2.2 Opérateurs arithmétiques
- 2.3 Opérateurs logiques
- 2.4 Valeurs vraies/fausses
- 3 Instructions Else, Elseif et Imbrication If
- service de 4
- 5 Paramètres
- 5.1 Tuples
- 6 Retour
- 7 Événements
- 8 cas
- 9 fonctions intégrées
- 9.1 Détruire()
- 9.2 Cloner()
- 9.3 EffacerTous les enfants()
- 9.4 FindFirstChild()
- 9.5 WaitForChild()
- 9.6 Attendre()
- Tables 10
- 11 boucles
- 12 Que signifie « local » ?
- 13 Scripts intermédiaires : exemples
- 13.1 Brique de mort/guérison polyvalente (difficulté : moyennement dure)
- 13.1.1 Extension : effet de guérison étendu
- 13.1.2 Extension : effet de disparition
- 13.1.3 Enregistrement du joueur
- 13.2 La porte VIP (Difficulté : Moyenne)
- 13.1 Brique de mort/guérison polyvalente (difficulté : moyennement dure)
Juste un examen rapide
Voici quelques concepts que vous devez connaître au préalable :
- Variables : espaces réservés pour les données
- Booléens : déclarations vrai/faux
- Valeurs de chaîne : valeurs de texte
- Propriétés : attributs d'un objet
- Fonctions : espaces réservés pour le code
- Parent : l'objet directement au-dessus d'un autre objet dans la fenêtre de l'explorateur
- Enfant : l'objet directement sous un autre objet dans la fenêtre de l'explorateur
Vous devriez avoir ouvert Roblox Studio pour cela, et vous devriez également avoir un script ouvert ainsi que votre explorateur, vos propriétés et votre sortie ouverts.
Si les déclarations
An if exécuterait un morceau de code if une condition est remplie. Par exemple:
1 Var local = 1 2 si Var == 1 alors 3 print("condition remplie") 4 end
Vous pouvez voir que je déclare une variable. Ensuite, le script rencontrera l'instruction if. Le script trouve que Var est 1, donc la condition est remplie, donc il imprimerait "condition remplie". N'oubliez pas les balises de fin ! Notez que dans une instruction if == doit être utilisé. == est pour comparer des valeurs et = est pour déclarer des variables.
Opérateurs relationnels
Si vous n'êtes pas déjà familiarisé avec les opérateurs relationnels, un opérateur relationnel est un opérateur qui compare deux nombres. En tant que tels, ils ne peuvent être utilisés que sur des valeurs flottantes et int. Les voici:
- == (Égal à)
- ~=(Non égal à)
- < (Inférieur à)
- > (Supérieur à)
- <= (inférieur ou égal à)
- >= (Supérieur ou égal à)
Ainsi, par exemple, certaines déclarations seraient :
Pour référence, si vous confondez les symboles supérieur à (>) et inférieur à (<), j'aime penser à ces symboles comme à une bouche d'alligator qui "mange" le plus grand nombre.
Opérateurs arithmétiques
Si vous avez des connaissances en mathématiques, sachez que les nombres peuvent être modifiés avec des opérateurs. Ceux-ci sont:
- + (Ajouter)
- - (Soustraire)
- * (Multiplier)
- / (Diviser)
- % (Module)
- ^ (Exposants)
Ainsi...
Si vous n'êtes pas clair avec les deux derniers opérateurs, module renvoie le reste lorsque les deux nombres sont divisés. Ainsi par exemple,
Parce que 7 n'est pas parfaitement divisible par 2, il laisse un reste de 1. Par conséquent, 7 mod 2 est 1.
Les exposants ne sont que des multiplications répétées.
Ainsi, 5^5 est juste 5 multiplié par lui-même 3 fois.
Pour effectuer une opération sur une valeur, vous devez effectuer une opération arithmétique avec la valeur, comme le montre cet exemple :
1 valeur = valeur + 1 --Ajoute 1 à la valeur. 2 valeur = valeur - 1 --Soustrait 1 de la valeur. 3 valeur = valeur / 2 -- Divise la valeur par 2. 4 valeur = valeur * 3 -- Multiplie la valeur par 3. 5 valeur = valeur % 3 -- Divise la valeur par 3, puis renvoie le reste. 6 valeur = valeur ^ 5 --Multiplie la valeur par elle-même 5 fois.
Pour plus de simplicité, ces opérations peuvent être raccourcies, comme le montre cet exemple :
1 valeur += 1 --ajoute 1 à la valeur 2 valeur -= 1 --(enlève 1 de la valeur) 3 valeur *= 2 --(multiplie la valeur par 2)
Voici un exemple d'opérateur arithmétique qui teste si oui ou non le joueur a assez d'argent :
1 si plr.Money.Value >= 120 alors 2 plr.Money.Value -= 120 3 end
Ici, il vérifie si le joueur possède 120 $ ou plus. Si c'est le cas, il le soustrait.
opérateurs logiques
Un opérateur logique combine deux opérateurs en un seul. Ceux-ci sont:
- et (vérifie si les DEUX conditions sont vraies)
- or (vérifie si l'une ou l'autre des conditions est vraie)
- pas (vérifie si l'état actuel est l'OPPOSÉ de la condition)
1 si valeur < 30 et valeur > 15 alors 2 --Code 3 fin 4 5 si valeur == "fromage" ou valeur == "tarte" then 6 --Code 7 fin 8 9 si non valeur == 12 alors 10 - -Code 11 fin
La première instruction if vérifie si la valeur est inférieure à 30, mais supérieure à 15. En d'autres termes, elle vérifie si la valeur est comprise entre 15 et 30. La seconde instruction if vérifie si la valeur est "fromage" ou "tarte", et le troisième vérifie si la valeur est pas 12.
Valeurs vraies/fausses
mais qu'est ce que ça veut dire?
1 si valeur alors 2 print("Oof") 3 end
Si il ya des aucune opérateurs, l'instruction if vérifie si la valeur est véridique or faux.
Pour être clair, un faux valeur (également connue sous le nom de faux valeur), est une valeur qui est soit faux or nul.
Toutes les autres valeurs sont prises en compte véridique valeurs.
La plupart du temps, cela est utilisé pour trouver si un instance existe. Donc, si je devais faire ça,
1 local Head = script.Parent:FindFirstChild("Head") 2 3 if Head then 4 print("Mon parent a un head.") 5 end
j'expliquerai plus tard ce que ChercherPremierEnfant() fait plus tard, mais fondamentalement, il trouve la partie nommée Tête.
Ce script vérifiera si son parent a un enfant nommé "Head". Si c'est le cas, il s'imprime.
Instructions Else, Elseif et Imbrication If
Vous pouvez également mettre une instruction if dans une autre. C'est appelé nidification une instruction if.
1 local Var1 = 1 2 local Var2 = false 3 si Var1 == 1 alors 4 si Var2 == false 5 print("Oof") 6 end 7 end
Le script verra que les deux conditions sont remplies, donc il s'imprime. N'oubliez pas que chaque instruction if a besoin de sa propre balise de fin.
Placement d'autre dans l'instruction if entraînera l'exécution d'un code alternatif par le script si la première condition n'est pas remplie.
1 local Var1 = 1 2 if Var1 == 2 then 3 print("condition satisfaite") 4 else 5 print("condition non satisfaite") 6 end
An elseif consiste essentiellement à combiner "else" avec une instruction if. Si la première condition n'est pas remplie, il vérifiera si une deuxième condition est remplie.
1 local Var1 = 1 2 local Var2 = false 3 if Var1 == 2 then 4 print("condition 1 satisfait") 5 elseif Var2 == false then 6 print("condition 2 satisfait") 7 end
Ainsi, le système définit les deux variables, puis doit décider si Var1 est égal à 2. Ce n'est pas le cas, il vérifie donc l'autre condition. Il est satisfait, il affiche donc "condition 2 satisfaite". Vous pouvez créer des instructions if aussi folles que vous le souhaitez, avec autant d'instructions elseifs et imbriquées que vous le souhaitez.
Service
Un service est le tout du niveau hiérarchique le plus élevé dans la fenêtre de l'explorateur. Les voici:
- Espace de travail : un service qui contient toutes les pièces et objets physiques du jeu.
- Joueurs : Un service qui gère tous les joueurs qui entrent dans le jeu.
- Éclairage : Gère les effets d'éclairage, l'heure de la journée et le soleil, la lune et le ciel.
- ReplicatedStorage : service contenant des objets répliqués vers tous les clients
- ServerScriptService : service contenant des scripts de serveur ; scripts à utiliser pour l'ensemble du jeu, c'est-à-dire pour les classements.
- ServerStorage : stockage pour les objets à utiliser ultérieurement.
- StarterGui : Service contenant ScreenGuis
- StarterPack : Service contenant des outils
- SoundService : stockage pour l'audio
- Chat : gère le chat
- LocalizationService : gère la traduction automatique
C'est beaucoup à déballer, alors concentrez-vous sur Espace de travail, car c'est le service le plus fréquemment utilisé, et le seul utilisé dans ce tutoriel. Dans le didacticiel avancé, nous commencerons à utiliser StarterGui.
Il existe également deux services que vous pouvez ajouter manuellement à la fenêtre de l'explorateur : Service de script répliqué et Équipes. Pour les ajouter, ouvrez le Voir Tab > Barre de commande. Ensuite, entrez ce qui suit :
1 jeu :GetService("ReplicatedScriptService") 2 jeu :GetService("Teams")
Ces services apparaîtront alors dans votre explorateur.
Bien sûr, il existe de nombreux autres services cachés de la fenêtre de l'explorateur. Pour y accéder à l'intérieur d'un script, vous devez utiliser le ObtenirService() fonction pour obtenir le service. Par exemple:
1 UserInputService local = jeu:GetService("UserInputService")
Maintenant, dans le script, le service UserInputService sera contenu dans la variable "UserInputService".
Paramètres
Dans le tutoriel pour débutants, j'ai expliqué ce qu'était une fonction : un espace réservé pour le code. On peut aussi permettre à une fonction d'avoir un argumentou paramètre (une valeur qui doit être saisie), par exemple :
1 fonction écriture (truc) 2 print (truc) 3 fin 4 5 écriture("Bonjour tout le monde !")
Lors de la déclaration d'une fonction, en mettant un paramètre entre parenthèses, la fonction attend alors une valeur. Ensuite, lorsque vous appelez la fonction, vous devez alors mettre une valeur entre parenthèses. Dans ce cas, la fonction attend une valeur pour "truc". Lorsque vous appelez la fonction, en mettant "Hello world!" entre parenthèses, vous définissez "truc" comme la chaîne "Hello world!" À partir de là, vous pouvez utiliser "truc" comme variable à l'intérieur de la fonction.
Tuples
On peut aussi faire ça :
1 fonction write(trucs, morestuff) 2 print(trucs) 3 print(trucs) 4 end 5 6 write("Bonjour", "monde!")
Le script ci-dessus attend deux paramètres : étoffe et Plus de matériel. Lors de l'appel de la fonction, nous définissons étoffe as Bonjour et Plus de matériel as monde!.
Vous pouvez avoir autant de paramètres que vous le souhaitez tant que vous les séparez par des virgules. Lorsque nous utilisons plus d'un argument, nous l'appelons un tuple.
Retour
Le renvoi d'une valeur est un moyen pour une fonction de générer une valeur. Un exemple concret de ceci est Google qui renvoie les résultats de votre recherche.
Disons que je voulais faire un convertisseur qui doublerait le nombre d'entrée. Faites simplement ceci :
1 fonction locale DoubleNumber(InputNumber) 2 local OutputNumber = InputNumber * 2 3 return OutputNumber 4 end 5 local Multiply = DoubleNumber(10) 6 print(Multiply)
Ici, la quatrième ligne lui dit de déclencher la fonction DoubleNuméro. La fonction double 10 pour faire 20 et renvoie 20. Ce nombre est contenu dans la variable "Multiplier". Cette variable peut être utilisée pour l'instruction print à la ligne 6.
Événements
Les événements sont essentiellement des situations spéciales qui peuvent être programmées pour provoquer une réaction. Le plus courant est Touché, qui peut être appliqué aux Pièces et aux Unions. Chaque fois que quelque chose touche une pièce, cela provoque l'appel d'une fonction.
1 fonction onTouch() 2 print("j'ai été touché D=") 3 end 4 5 script.Parent.Touched:connect(onTouch)
Décomposons cela.
"script.Parent" fait évidemment référence à la partie qui a été touchée. Contact(), comme son nom l'indique, relie l'événement à la fonction. En d'autres termes, chaque fois que l'événement se produit (lorsque la partie est touchée par une partie ou un joueur), la fonction se déclenche.
Les événements ont également des paramètres intégrés. Dans l'événement Touché, son paramètre est la personne ou la chose qui l'a touché.
1 fonction onTouch(whotouched) 2 whotouched:Destroy() 3 end 4 5 script.Parent.Touched:connect(onTouch)
Dans ce cas, vous appelez la chose qui a touché l'objet « qui a touché ». Ainsi, lorsque vous déclenchez l'événement, il déclenche la fonction et la fonction détruit l'élément qui a déclenché l'événement.
Il existe une pléthore d'autres événements, mais pour les scripteurs intermédiaires, Touched sera le plus important.
Une autre façon de déclencher un événement est de faire ceci :
1 script.Parent.Touched:Connect(function(whoTouched) 2 whoTouched:Destroy() 3 end)
C'est une façon d'utiliser moins de lignes.
Instance
Une instance est tout objet ou propriété du jeu. Et si vous vouliez créer un script qui crée une pièce ? Vous POUVEZ faire ça.
1 Brique locale = Instance.new("Part",game.Workspace)
Ici, je crée une nouvelle instance. Le premier paramètre "Part" est le nom de classe de l'instance, ou le type d'objet dont il s'agit. Donc, je crée une partie. Il a également un deuxième paramètre, pour son parent.
Cependant, il s'agit d'une mauvaise pratique courante. Ce n'est jamais une bonne idée d'utiliser le paramètre Parent. Cela ne fait que ralentir la fonction.
Au lieu de cela, définissez le parent dans la ligne suivante.
1 Brick local = Instance.new("Part") 2 Brick.Parent = game.Workspace
Et si nous voulons définir des propriétés ? Simple. Après le code ci-dessus, tapez ceci :
1 Brique.Transparence = 1 2 Brique.Nom = "Bloquer"
Le système sait déjà quoi Brique moyens. Il suffit de définir les propriétés.
Fonctions intégrées
Ce sont les fonctions qui sont définies dans le jeu, et aucune fonction personnalisée ne peut être déclarée avec le nom.
Détruire()
Cette fonction définit effectivement le parent de l'objet sur nil, le retirant du jeu. Par exemple:
1 script.Parent:Détruire()
Cloner()
Crée un duplicata de la pièce, avec toutes les mêmes propriétés, à l'exception du mère. Vous devez encore le définir dans la ligne suivante.
1 Clone local = script.Parent:Clone() 2 Clone.Parent = game.Workspace
EffacerTous les enfants()
Détruit tous les enfants de l'objet. Par exemple, si vous deviez l'utiliser sur l'espace de travail, cela supprimerait tout dans l'espace de travail.
1 script.Parent:ClearAllChildren()
ChercherPremierEnfant()
Si vous n'êtes pas sûr de l'existence ou non d'une variable ou d'une instance, FindFirstChild() accédera à l'objet s'il existe ; sinon, le script s'exécutera toujours, tandis que si vous essayez simplement d'accéder à une valeur nulle, le script se brisera.
Pour exécuter le code uniquement si quelque chose existe, utilisez une instruction if pour exécuter le code uniquement si l'objet dans FindFirstChild n'est pas égal à nil.
1 script.Parent:FindFirstChild("Feu")
WaitForChild()
Similaire à FindFirstChild, mais au lieu de renvoyer une valeur nulle si l'objet n'existe pas, il rendementou attendez.
1 jeu. Espace de travail : WaitForChild ("Partie") 2 print(1)
Ici, le script va attendez pour une instance nommée "Part", et ne continuera jamais JUSQU'À ce qu'elle existe.
Attendez()
Retarde un code d'un nombre défini de secondes. Réglez le temps en secondes comme paramètre. S'il n'y a pas de paramètre, par défaut il attendra 1 seconde. Cela attend également s'il n'y a pas de nombre entre les parenthèses, bien que pendant une période de temps extrêmement courte.
1 wait(0.5) --Délai une demi-seconde. 2 wait() --Retarde 1 seconde. 3 wait(2) --Délai 2 secondes.
Tables
Les tableaux, également appelés tableaux, sont un type de variable dans Lua qui peut être utilisé pour stocker plusieurs éléments de données dans la même variable, par exemple :
1 a = {a,b,c}
Maintenant vous devez savoir qu'il y a deux valeurs principales d'une table : i et v. i, ou Position de l'index, est la position de la valeur dans le tableau. Dans le tableau ci-dessus, parce que "a" est le premier nombre, sa valeur i est 1. "b" est la 2ème valeur, donc sa valeur i est 2, et la valeur i de c est 3. v, ou Valeur, est la donnée elle-même.
Donc, si vous voulez trouver la valeur v étant donné la valeur i, vous devrez le faire.
1 à [2]
En gros, cela indique à notre script d'accéder à la deuxième valeur du tableau a. Maintenant, supposons que nous voulions imprimer les 2 dernières valeurs du tableau suivant :
1 a = {"trois mille", "neuf cent", "et un"}
Ce que nous ferions, c'est ceci :
1 impression(a[2]) 2 impression(a[3])
Nous pouvons également attribuer des valeurs à des espaces individuels dans une table :
1 a[2] = "lol" 2 print(a[2])
Cela imprimerait le texte lol dans notre sortie, car la valeur du deuxième espace dans la table "a" a été changée en "lol".
Boucles
A boucle est essentiellement un morceau de code qui s'exécute à plusieurs reprises. Notez que quel que soit le type de boucle que vous utilisez, vous DEVEZ utiliser une fonction d'attente (délai). C'est parce que le système exécutera le code si infiniment vite que sans délai, le serveur se bloquera et cessera de répondre.
Alors que les boucles
La boucle la plus simple est une boucle "while", qui agit essentiellement comme ceci :
1 a = true 2 while a == true do 3 wait(0.1) 4 print("Je peux balancer mon épée") 5 end
Fondamentalement, cela fait que le script vérifie continuellement si a est toujours vrai toutes les 1 secondes, et si a est toujours vrai, le code dans la boucle s'exécutera à nouveau.
Si vous vouliez une boucle while pour continuer à exécuter du code inconditionnellement, vous feriez ceci :
1 tandis que true do 2 --Code 3 end
Pour les boucles
Une deuxième boucle, plus compliquée, est la boucle "for", qui peut se répéter un certain nombre de fois, par exemple :
1 pour i = 1,6 do 2 wait(0.1) 3 print("Bonjour maman!") 4 end
Fondamentalement, cela fait que le script compte de 1 à 6, en exécutant le code à chaque fois. Alors, "Bonjour maman!" serait imprimé 6 fois.
Si vous voulez vous faire plaisir...
L'ajout de la troisième partie fait que notre boucle for compte en 2, ce qui signifie que notre script comptera de 2 à 6 en 2, et s'exécutera chaque fois que vous pourrez ajouter 2 à 2 avant qu'il ne devienne 6.
1 pour i = 2,6,2 do 2 wait(0.1) 3 print("Bonjour papa!") 4 end
On peut aussi imprimer i :
1 pour i = 1,6 do 2 wait(0.1) 3 print(i) 4 end
Ce que cela fait essentiellement faire à notre script est de compter de 1 à 6 et chaque fois qu'il compte 1, il imprime la valeur à laquelle il se trouve.
Boucles en paires
Cette boucle nécessitera une compréhension des tables, que vous devriez avoir appris ci-dessus.
Une boucle par paires est une boucle qui implique les valeurs d'un tableau.
1 local Parts = game.Workspace.Folder:GetChildren() 2 pour index,Part in ipairs(Parts) do 3 print(index) 4 Part:Destroy() 5 wait(0.5) 6 end
Ce que fait GetChildren(), c'est qu'il renvoie un tableau contenant toutes les valeurs d'instance dans chaque dossier. Ensuite, j'ai renommé i en index et v en Part. Ensuite, j'ai dit au script quelle table je voulais utiliser après "par paires". Ensuite, entre des intervalles d'une demi-seconde, le script compterait le nombre de parties au fur et à mesure qu'il détruisait chaque partie une par une.
Que signifie « local » ?
Dans le didacticiel pour débutants, j'ai mentionné que les variables devraient être précédées de «local». Maintenant que vous avez acquis des compétences importantes, je peux vous expliquer ce que cela signifie.
Pour comprendre cela, vous devez comprendre les blocs. Vous remarquerez que j'ai demandé que vous indentiez le code dans les instructions if, les fonctions et les boucles. Le code entier est un bloc de code en lui-même, et tout code à l'intérieur des boucles, des fonctions et des instructions if est un autre bloc. Vous pouvez voir avec l'image de droite qu'il y a quatre niveaux de blocs dans ce script.
Alors, que signifie « local » ? Eh bien, cela signifie que la variable n'est accessible que dans ce bloc. Ce mot-clé est similaire à JavaScript let. Donc si je devais utiliser le code suivant :
1 db local = false 2 if db == false then 3 local var = 1 4 end 5 print(var)
Le script produirait une erreur, car l'instruction print essaie d'accéder à une variable accessible uniquement dans l'instruction if.
1 local db = false 2 local var 3 if db == false then 4 var = 1 5 end 6 print(var)
Vous pouvez voir que sur la deuxième ligne, je n'ai pas donné de valeur à var, elle est donc automatiquement définie sur nil. Ensuite, l'instruction if fera que var sera égal à 1. Il n'est plus « local » car l'instruction if met simplement à jour une variable déjà existante.
Script intermédiaire : exemples
Brique de mort/guérison polyvalente (Difficulté : moyennement dure)
Super! Maintenant que nous avons défini nos concepts, commençons à craquer. Disons que nous voulions une brique qui enlève la tête de Shedletsky chaque fois qu'il marche dessus, mais elle guérirait les autres joueurs lorsqu'ils marchent dessus. Alors, créez un script et placez-le dans une brique à l'aide de l'explorateur - Ensuite, créons notre fonction qui sera appelée par l'événement Touched et notre valeur qui sera attribuée par l'événement Touched (pour vérifier s'il s'agit bien de Shedletsky, bien sûr !) :
1 fonction tactile (shedletskycheck)
Super! Nous avons la fonction touch avec l'argument shedletskycheck. Maintenant, nous devons énoncer ce que fait notre fonction. Nous voulons que notre fonction vérifie d'abord Shedletsky :
1 fonction touch(shedletskycheck) 2 '''if shedletskycheck.Parent.Name == "Shedletsky" then'''
Le script vérifie maintenant si ce qui a touché le nom du parent de la brique était Shedletsky. Maintenant, nous devons créer un chemin menant de la brique touchante à la tête de Shedletsky :
1 fonction touch(shedletskycheck) 2 if shedletskycheck.Parent.Name == "Shedletsky" then 3 shedletskycheck.Parent.Head:remove() 4 --Nous avons navigué de shedletskycheck à son parent, qui est le modèle Shedletsky lui-même, puis nous avons trouvé la Tête dans le modèle Shedletsky.
Maintenant, disons que quelque chose qui N'ÉTAIT PAS Shedletsky a touché la brique. Selon notre description de script, nous devons vérifier si tout ce qui a touché la brique qui n'était pas Shedletsky était même un joueur, alors nous devons le soigner. En tant que tel, nous devons trouver si le parent de la partie touchante contenait un humanoïde. Pour ce faire, nous devons utiliser une méthode ;findFirstChild() (Si vous ne savez pas ce que c'est, consultez le guide du débutant sur les scripts.)
1 fonction touch(shedletskycheck) 2 if shedletskycheck.Parent.Name == "Shedletsky" then 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil then
En utilisant l'instruction elseif, si les conditions pour le "if" précédent (qui est celui qui a touché la brique étant Shedletsky") ne sont pas remplies, alors l'instruction elseif vérifie la condition suivante (dans ce cas, si le parent de la brique avait même un Humanoïde dedans, indiquant si ce qui a touché la brique était même un joueur), puis nous avons exécuté une méthode :findFirstChild() sur le parent de la partie en contact, et s'il a trouvé un humanoïde dans le parent de la partie en contact, il renvoie ~= nil, cependant s'il n'en a pas trouvé, il renvoie nil.
Maintenant, nous devons les guérir :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstchild("Humanoid") ~= nil puis 5 shedletskycheck.Parent. Humanoid.Health = shedletsky.Parent.Humanoid.MaxHealth
Cela définit essentiellement la valeur de leur santé par rapport à leur santé maximale, les guérissant efficacement à pleine capacité. Hourra ! Nous avons presque notre script. Maintenant, tout ce que nous avons à faire est d'ajouter une "fin" pour chaque "fonction" et "if" que nous avons, à l'exception des "elseif".
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 5 shedletskycheck.Parent. Humanoid.Health = shedletsky.Parent.Humanoid.MaxHealth 6 fin 7 fin
Nous avons une fonction et une si, en excluant le "if" dans "elseif", nous avons donc ajouté deux extrémités.
Enfin, nous devons ajouter la connexion :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 5 shedletskycheck.Parent. Humanoid.Health = shedletsky.Parent.Humanoid.MaxHealth 6 end 7 end 8 script.Parent.Touched:connect(touch)
Hourra ! Maintenant, si nous exécutons notre script dans Play Solo, si vous renommez un personnage Shedletsky, lorsqu'il touche la brique, sa tête doit être retirée ! Cependant, si vous vous blessez et que vous touchez la brique, vous devriez être guéri en pleine santé !
Extension : effet de guérison étendu
Maintenant, disons que nous ne voulions pas que notre brique guérisse les autres joueurs instantanément, mais à la place, elle les guérirait en 20 toutes les 5 secondes 5 fois. Vous l'avez deviné : nous utilisons des boucles "for".
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 5 pour i = 1,5 ,6 do 7 end 8 end XNUMX script.Parent.Touched:connect(touch)
Nous avons donc remplacé le code de guérison initial par une boucle "for" qui compte de 1 à 5 (de 1 à 5 fois), ensuite nous devons ajouter le code de guérison pour que l'humanoïde gagne 20 points de vie supplémentaires (j'ai utilisé une variable pour définir le humanoïde dans ce cas pour raccourcir le code, mais ce n'est pas nécessaire) et ajoutez la méthode wait qui fait attendre le script 5 secondes avant d'ajouter plus de santé :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 5 pour i = 1,5 ,6 do 5 wait(7) 8 b = shedletskycheck.Parent:findFirstChild("Humanoid") 20 b.Health = b.Health + 9 10 end 11 end XNUMX script.Parent.Touched:connect(touch)
Nous avons donc ajouté une instruction wait qui fait attendre le script 5 secondes, puis il - bien sûr - a trouvé l'humanoïde et a défini sa valeur à sa valeur d'origine plus 20. (La valeur d'une variable n'est pas constante, c'est ce qu'elle était quand sa valeur a été définie. La variable ne se met pas à jour en permanence. D'où :
1 a = 1 2 b = a 3 wait(1) 4 a = 2 5 print(b)
Afficherait en fait 1, car au moment où b était défini sur a, a était 1, mais plus tard, a a été changé en 2, mais puisque les variables ne sont pas constantes, b est resté 1.)
Maintenant, enfin, nous devons terminer la boucle par un "fin":
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" puis 3 shedletskycheck.Parent.Head:remove() 4 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 5 pour i = 1,5 ,6 do 5 wait(7) 8 b = shedletskycheck.Parent:findFirstChild("Humanoid") 20 b.Health = b.Health + 9 10 end 11 end 12 end XNUMX script.Parent.Touched:connect(touch)
Si vous l'avez fait correctement, lorsque vous marchez sur le bloc scripté dans Play Solo, si vous êtes endommagé, vous devriez lentement gagner de la santé (à moins que vous ne vous appeliez Shedletsky.)
Extension : effet de disparition
Maintenant, disons que nous voulions que notre script augmente continuellement la transparence de la tête de Shedletsky toutes les 1 seconde, et lorsque la transparence de sa tête atteint 1, SEULEMENT ALORS le script supprimera la tête de Shedletsky. Nous allons utiliser d'autres boucles "for". (J'ai utilisé une variable pour définir la transparence de la tête de shedletsky, mais vous n'êtes pas obligé)
1 fonction touch(shedletskycheck) 2 if shedletskycheck.Parent.Name == "Shedletsky" then 3 trans = shedletskycheck.Parent.Head.Transparency 4 for i = 1,10 do 5 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~ = nil puis 6 pour i = 1,5 do 7 b = shedletskycheck.Parent:findFirstChild("Humanoid") 8 b.Health = b.Health + 20 9 end 10 end 11 end 12 script.Parent.Touched:connect(touch )
Nous avons donc remplacé le code de réglage de la transparence de base par une boucle "for" qui comptait de 1 à 10 et définissait la transparence de la tête de shedletsky comme la variable trans. Maintenant, il faut ajouter la partie où sa transparence est augmentée :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" alors 3 trans = shedletskycheck.Parent.Head.Transparency 4 pour i = 1,10 do 5 trans = trans + 0.1 6 elseif shedletskycheck.Parent:findFirstChild ("Humanoid") ~= nil then 7 for i = 1,5 do 8 b = shedletskycheck.Parent:findFirstChild("Humanoid") 9 b.Health = b.Health + 20 10 end 11 end 12 end 13 script.Parent .Touché : connecter (toucher)
Alors maintenant, cela augmentera la transparence de la tête de 1 10 fois (une valeur de transparence de 1 rend une brique entièrement invisible). Maintenant, nous devons ajouter l'instruction qui fait attendre le script 1 seconde entre les augmentations de transparence :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" alors 3 trans = shedletskycheck.Parent.Head.Transparency 4 pour i = 1,10 do 5 wait(0.1) 6 trans = trans + 0.1 7 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil then 8 for i = 1,5 do 9 b = shedletskycheck.Parent:findFirstChild("Humanoid") 10 b.Health = b.Health + 20 11 end 12 end 13 fin 14 script.Parent.Touched:connect(touch)
Enfin, nous ajoutons l'instruction de fin :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" alors 3 trans = shedletskycheck.Parent.Head.Transparency 4 pour i = 1,10 do 5 wait(0.1) 6 trans = trans + 0.1 7 end 8 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil then 9 for i = 1,5 do 10 b = shedletskycheck.Parent:findFirstChild("Humanoid") 11 b.Health = b.Health + 20 12 end 13 fin 14 fin 15 script.Parent.Touched:connect(touch)
Et la partie qui enlève la tête de Shedletsky :
1 fonction touch(shedletskycheck) 2 si shedletskycheck.Parent.Name == "Shedletsky" alors 3 trans = shedletskycheck.Parent.Head.Transparency 4 pour i = 1,10 do 5 wait(0.1) 6 trans = trans + 0.1 7 end 8 shedletskycheck.Parent.Head:remove() 9 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil alors 10 pour i = 1,5 do 11 b = shedletskycheck.Parent:findFirstChild("Humanoid") 12 b. Health = b.Health + 20 13 end 14 end 15 end 16 script.Parent.Touched:connect(touch)
Alors maintenant, lorsque vous exécutez le script dans Play Solo, si vous vous nommez Shedletsky, lorsque vous marchez sur la brique, votre tête devrait progressivement disparaître jusqu'à ce que vous mouriez.
Enregistrement du joueur
Supposons donc qu'à ce stade vous vouliez enregistrer tous les joueurs non Shedletsky qui vont marcher sur cette brique, pour cela nous devons utiliser une table :
1 t = {un} 2 fonction touch(shedletskycheck) 3 si shedletskycheck.Parent.Name == "Shedletsky" alors 4 trans = shedletskycheck.Parent.Head.Transparency 5 pour i = 1,10 do 6 wait(0.1) 7 trans = trans + 0.1 8 end 9 shedletskycheck.Parent.Head:remove() 10 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 11 pour i = 1,5 do 12 b = shedletskycheck.Parent:findFirstChild(" Humanoïde") 13 b.Health = b.Health + 20 14 end 15 end 16 end 17 script.Parent.Touched:connect(touch)
Nous avons créé un tableau avec le contenu "un". Cela aidera plus tard. Ensuite, récupérez le nombre maximum de notre table en utilisant la méthode table.maxn(), qui renvoie l'espace le plus élevé dans la table :
1 t = {un} 2 fonction touch(shedletskycheck) 3 maxn = table.maxn(t) 4 si shedletskycheck.Parent.Name == "Shedletsky" then 5 trans = shedletskycheck.Parent.Head.Transparency 6 pour i = 1,10, 7 do 0.1 wait(8) 0.1 trans = trans + 9 10 end 11 shedletskycheck.Parent.Head:remove() 12 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 1,5 pour i = 13 do 14 b = shedletskycheck.Parent:findFirstChild("Humanoid") 20 b.Health = b.Health + 15 16 end 17 end 18 end XNUMX script.Parent.Touched:connect(touch)
Maintenant, nous devons faire en sorte que notre table insère les noms des joueurs enregistrés en utilisant la méthode table.insert() - table.insert(table,location,value):
1 t = {un} 2 fonction touch(shedletskycheck) 3 maxn = table.maxn(t) 4 si shedletskycheck.Parent.Name == "Shedletsky" then 5 trans = shedletskycheck.Parent.Head.Transparency 6 pour i = 1,10, 7 do 0.1 wait(8) 0.1 trans = trans + 9 10 end 11 shedletskycheck.Parent.Head:remove() 12 elseif shedletskycheck.Parent:findFirstChild("Humanoid") ~= nil puis 1,5 pour i = 13 do 14 b = shedletskycheck.Parent:findFirstChild("Humanoid") 20 b.Health = b.Health + 15 16 end 1 table.insert(t,(maxn - 17),shedletskycheck.Parent.Name) 18 end 19 end XNUMX script. Parent.Touché : connecter (toucher)
Ce que cela fait, c'est qu'il obtient la place la plus élevée dans la table, la soustrait de un et y insère la valeur du nom. Nous faisons cela pour nous assurer que la table ajoutera un nouveau nom dans un nouvel espace. Maintenant, faisons en sorte qu'il imprime la table entière lorsqu'elle est touchée en utilisant deux méthodes : la méthode tostring et la méthode table.concat. La méthode table.concat prend essentiellement toutes les valeurs d'une table et les écrase ensemble. La méthode tostring convertit n'importe quelle valeur (telle qu'une valeur de table) en une valeur de chaîne.
1 t = {un} 2 fonction touch(shedletskycheck) 3 maxn = table.maxn(t) 4 print(tostring(table.concat(t,' '))) 5 si shedletskycheck.Parent.Name == "Shedletsky" alors 6 trans = shedletskycheck.Parent.Head.Transparency 7 for i = 1,10 do 8 wait(0.1) 9 trans = trans + 0.1 10 end 11 shedletskycheck.Parent.Head:remove() 12 elseif shedletskycheck.Parent:findFirstChild(" Humanoïde") ~= nil then 13 for i = 1,5 do 14 b = shedletskycheck.Parent:findFirstChild("Humanoid") 15 b.Health = b.Health + 20 16 end 17 table.insert(t,(maxn - 1),shedletskycheck.Parent.Name) 18 fin 19 fin 20 script.Parent.Touched:connect(touch)
La porte VIP (Difficulté : Moyenne)
Supposons maintenant que vous vouliez une brique qui ne permette qu'à une certaine personne de la traverser mais qui tue toutes les autres. Créez d'abord une brique. Mettez un script dans la brique, ensuite, ouvrez sa source. Tout d'abord, nous devons créer une fonction à appeler par l'événement Touched et la valeur qui sera définie par l'événement Touched :
1 fonction onTouch (vip)
Nous avons donc une fonction onTouch et un argument "vip". Ensuite, nous créons une instruction "if" pour vérifier si ce qui a touché la brique était un joueur nommé "Bob":
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors
Notre script vérifie maintenant si le nom du parent de tout ce qui a touché la brique était Bob. Ensuite, puisque nous voulons que notre script permette à Bob de passer, nous définissons la valeur du cancollide de la brique sur "false" pendant 1 seconde. La propriété CanCollide est la propriété qui rend une brique solide.
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.CanCollide = false 4 wait(1) 5 script.Parent.CanCollide = true
Notre script maintenant, lorsqu'il est touché par Bob, définit le CanCollide de la brique sur false, permettant à Bob de passer, et après 1 seconde - wait(1), il définit le CanCollide de la brique sur true, ne laissant pas les autres passer. Maintenant, nous voulons que Bob sache quand la porte est ouverte, nous allons donc rendre la brique semi-transparente tandis que le CanCollide de la brique est faux :
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = false 5 wait(1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = vrai
Notre script maintenant, lorsqu'il est touché par Bob, modifie non seulement la valeur du CanCollide de la brique, mais le rend également semi-transparent afin que Bob sache quand la porte est ouverte. Après 1 seconde - wait(1), en même temps que CanCollide est défini sur true, la transparence est définie sur 0 afin que Bob sache quand la porte est fermée. Ensuite, nous ajoutons la partie qui vérifie si (hypothétiquement parlant) tout ce qui a touché le bloc N'ÉTAIT PAS Bob était même un joueur.
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = false 5 wait(1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = true 8 elseif vip.Parent:findFirstChild("Humanoid") ~= nil then
Donc, si les conditions de la première instruction "if" (le toucher étant Bob) ne sont pas remplies, alors il effectue une vérification supplémentaire qui indique si le toucher était même un joueur. Maintenant, la partie amusante : tuer le joueur.
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = false 5 wait(1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = true 8 elseif vip.Parent:findFirstChild("Humanoid") ~= nil then 9 vip.Parent.Humanoid.Health = 0
Donc, notre déclaration va maintenant mettre à zéro la santé de l'humanoïde trouvé. Enfin, fermons notre "function" et ou "if" (à l'exclusion de notre "elseif")
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = false 5 wait(1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = true 8 elseif vip.Parent:findFirstChild("Humanoid") ~= nil then 9 vip.Parent.Humanoid.Health = 0 10 end 11 end
Et enfin, créons l'instruction de connexion (qui fait que tout se passe :)
1 fonction onTouch(vip) 2 si vip.Parent.Name == "Bob" alors 3 script.Parent.Transparency = 0.5 4 script.Parent.CanCollide = false 5 wait(1) 6 script.Parent.Transparency = 0 7 script .Parent.CanCollide = true 8 elseif vip.Parent:findFirstChild("Humanoid") ~= nil then 9 vip.Parent.Humanoid.Health = 0 10 end 11 end 12 script.Parent.Touched:connect(onTouch)
Toutes nos félicitations! Si votre script a fonctionné, toute personne nommée "Bob" devrait pouvoir passer la porte, mais toute personne qui n'est pas Bob sera tuée par la porte ! Vous pouvez remplacer « Bob » par le nom de votre choix une fois que vous êtes prêt à le mettre en œuvre chez vous !
C'est tout pour le guide intermédiaire ! Accédez au guide de script avancé pour continuer.
