Close
    Search Search

    Tutoriel : Guide avancé sur les scripts

    Page du didacticielCet article est un tutoriel avancé.Tous les tutoriels · Tutoriels de script

    Bienvenue dans Advanced Scripting ! Ce tutoriel plongera dans des termes et concepts plus techniques de scripting Roblox. Voici un bref aperçu de ce que nous avons appris jusqu'à présent.

    • 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
    • If Statement : une instruction qui exécute le code si une condition est remplie
    • Else : une instruction qui exécute le code si une condition n'est pas remplie
    • Elseif : une instruction qui exécute le code si une première condition n'est pas remplie mais qu'une deuxième condition l'est.
    • Tables/Index : un ensemble de valeurs multiples.
    • Boucles While : une instruction qui exécute le code encore et encore à l'infini tant qu'une condition est remplie.
    • Boucles For : une instruction qui exécute le code encore et encore pour un nombre défini de fois.
    • In Pairs Loops : une instruction qui exécute le code qui s'applique à une certaine table.
    • Fonctions intégrées : une fonction déjà créée par Roblox.

    Contenu

    Nos valeurs

    Jusqu'à présent, nous avons appris que vous ne pouvez pas accéder aux variables d'autres scripts. Mais et s'il le faut ? Vous pouvez utiliser une valeur. Ce sont des variables qui ne sont pas à l'intérieur d'un script, mais que vous ajoutez à la fenêtre de l'explorateur. Vous pouvez le faire en l'insérant dans une pièce. Il existe plusieurs types de valeurs, mais vous voyez l'idée. Pour y accéder, il suffit de le référencer comme vous le feriez avec une pièce.





    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Espace de travail
      • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Partie
        • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts scénario
        • Tutoriel : Guide avancé sur les scripts BoolValue

    Pour définir la valeur dans un script, vous modifiez son Valeur propriété.

    1 script.Parent.BoolValue.Value = false

    Une erreur extrêmement courante lors de la définition des valeurs est que les développeurs oublient souvent d'ajouter ".Value" à leur script. Ceci est obligatoire car il s'agit de la propriété Value que vous essayez de définir.

    Il existe plusieurs types de Valeurs : Valeurs booléennes, Valeurs de chaîne, IntValues, NombreValeursainsi que CframeValues.

    Maintenant, voici le truc : si quelque chose a beaucoup d'objets Value, pour des raisons d'organisation, nous aimons le mettre dans un Dossier de configuration.

    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Partie
      • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts configuration
        • Tutoriel : Guide avancé sur les scripts BoolValue
        • Tutoriel : Guide avancé sur les scripts Valeur de chaîne
        • Tutoriel : Guide avancé sur les scripts IntValue

    Bien sûr, comme les dossiers normaux, cela est entièrement facultatif, mais si vous choisissez de l'utiliser, vous devez créer un chemin comme celui-ci :

    1 jeu.Workspace.Part.Configuration.BoolValue.Value = false

    Statistiques des leaders

    Supposons que vous fassiez du Monopoly dans Roblox et que vous vouliez créer un classement en haut à droite de votre jeu pour enregistrer les places et l'argent des joueurs. Commencez par faire le classement en ajoutant un dossier nommé statistiques des leaders parent d'un joueur à chaque fois qu'il s'est joint. Nous utilisons le JoueurAjouté événement dans le joueurs après-vente.


    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts ServerScriptService
      • Tutoriel : Guide avancé sur les scripts scénario

    1 game.Players.PlayerAdded:Connect(function(player) 2 leaderstats local = Instance.new("Dossier") 3 leaderstats.Name = "leaderstats" 4 leaderstats.Parent = player 5 end)

    Notez que le nom du dossier doivent être « leaderstats » ; Roblox n'acceptera aucune autre variante.


    Maintenant, ajoutez simplement IntValues, Valeurs de chaîne, NombreValeurs et Valeurs booléennes faire des statistiques réelles.

    Nous voulons faire des statistiques pour la case actuelle sur laquelle se trouve le joueur, ainsi que le montant d'argent donné. UNE Valeur de chaîne fonctionnerait mieux pour l'emplacement, et un IntValue fonctionnerait mieux pour le montant en espèces, en supposant que vous ne vouliez pas utiliser un signe dollar ($) dans les statistiques.

    Donc, nous créons les deux valeurs en utilisant le .nouveau constructeur, puis changez son Nom et Parent.

    1 game.Players.PlayerAdded:Connect(function(player) 2 local leaderstats = Instance.new("Dossier") 3 leaderstats.Name = "leaderstats" 4 leaderstats.Parent = player 5 6 local Cash = Instance.new("IntValue ") 7 Cash.Name = "Cash" 8 Cash.Parent = leaderstats 9 10 Local Location = Instance.new("StringValue") 11 Location.Name = "Location" 12 Location.Parent = leaderstats 13 end)

    Maintenant, traditionnellement, au Monopoly, nous commençons au "GO" et recevons 1500 $. Donc, vous définissez son Valeur propriété.

    1 game.Players.PlayerAdded:Connect(function(player) 2 local leaderstats = Instance.new("Dossier") 3 leaderstats.Name = "leaderstats" 4 leaderstats.Parent = player 5 6 local Cash = Instance.new("IntValue ") 7 Cash.Name = "Cash" 8 Cash.Value = 1500 9 Cash.Parent = leaderstats 10 11 Local Location = Instance.new("StringValue") 12 Location.Name = "Location" 13 Location.Value = "GO " 14 Location.Parent = leaderstats 15 fin)


    Bien sûr, vous devrez ajouter manuellement des emplacements de réapparition à GO pour que les joueurs y apparaissent, mais cela indiquerait quand même GO dans le classement.


    Détecteurs de clics

    Pour les pièces, un détecteur de clic est un détecteur lorsque le joueur passe son curseur dessus. Pour en ajouter un, insérez-le simplement dans la partie, et si vous testez le jeu, vous pouvez voir que le curseur change chaque fois que vous le survolez. Cependant, rien ne se passe. C'est parce que vous ne l'avez jamais scripté pour faire quoi que ce soit. Insérez donc un script dans le ClickDetector :

    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Espace de travail
      • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Partie
        • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts Détecteur de clics
          • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts scénario

    1 script.Parent.MouseClick:Connect(function() 2 print("partie cliquée") 3 end)

    Lorsque vous faites un clic gauche sur la pièce, vous déclenchez le Clic de souris un événement. Ainsi, il est connecté à la fonction qui imprime "partie cliquée".

    Enum

    Enum, court pour énumération, est un type de données qui prend l'une des valeurs d'un ensemble. Dans la fenêtre Propriétés, une propriété qui utilise Enum serait représentée par un menu déroulant. Pour une partie, le Forme et Matériel les propriétés utilisent toutes les deux Enum.

    1 script.Parent.Material = Enum.Material.Neon

    C'est une alternative à la mise "Neon" dans les chaînes. Cela peut être facultatif pour des choses comme le matériel, mais est requis pour des choses comme Style d'assouplissement, que nous expliquerons plus tard.

    ÉcranGuis

    A ÉcranGui peuplements pour interface utilisateur graphique à l'écran. Pour ceux qui ne sont pas aussi avertis avec la technologie, c'est essentiellement comme un autocollant placé sur l'écran qui est pas partie de l'espace tridimensionnel. En tant que tels, ils ne sont jamais placés dans l'espace de travail. Ils sont placés dans StarterGui. Ajoutez donc un ScreenGui et vous verrez qu'un onglet appelé UI devrait apparaître en haut. Cliquez sur cet onglet et vous verrez diverses interfaces utilisateur, telles que des boutons de texte, des étiquettes d'image, etc. Concevez l'interface graphique autant que vous le souhaitez.

    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts StarterGui
      • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts ÉcranGui
        • Tutoriel : Guide avancé sur les scripts Bouton de texte
        • Tutoriel : Guide avancé sur les scripts ÉtiquetteImage
        • Tutoriel : Guide avancé sur les scripts Monture

    Si vous voulez savoir comment modifier la position et la taille en utilisant les propriétés au lieu de faire glisser, lisez ici.

    Le modèle client-serveur

    Le modèle client-serveur est un moyen par lequel Roblox gère ses jeux.

    Un "serveur" est une sorte d'ordinateur/système puissant contrôlant tous les événements qui se produisent dans un jeu. Il gère également tous les joueurs d'une partie.

    Le "client" est l'appareil de chaque utilisateur individuel.

    réplication

    Nous savons tous qu'un changement dans un jeu se produit chaque fois qu'une propriété est modifiée, ou lorsqu'une instance est créée ou détruite. Il existe deux types de changements : un côté serveur et un côté client. Un changement côté serveur se produit lorsque le changement se produit sur le serveur (tous les joueurs subissent ce changement), alors qu'un changement côté client se produit sur un client spécifique (un seul joueur remarque ce changement). Lorsque vous utilisez un script normal, ce code provoque des modifications côté serveur.

    Automatiquement, les modifications côté serveur sont répliquées sur le client : cela signifie que lorsqu'une modification côté serveur se produit, la même modification se produit sur le client.

    Filtrage activé

    Voici où les choses se compliquent : si vous regardez les propriétés de l'espace de travail, vous trouverez un booléen intitulé FilteringEnabled. Cela signifie que si les modifications côté serveur peuvent être répliquées sur le client, une modification côté client ne peut pas être répliquée sur le serveur. Cela sert en quelque sorte de précaution de sécurité dans le jeu : si un exploiteur devait pirater le jeu et apporter des modifications malveillantes, ce changement ne se produira pas pour les autres joueurs du jeu. Notez que vous ne pouvez plus désactiver cette propriété ; il a été forcé en 2018.

    Scripts locaux

    A script local est un script qui n'affectera que le côté client. Ils sont particulièrement utiles pour des choses comme UserInputService et ScreenGuis. Ainsi, si un joueur clique sur un bouton qui fait apparaître des théières, si un script local est utilisé, seul ce joueur verra les théières.

    Essayons de l'utiliser pour imprimer du texte sur un bouton chaque fois qu'on clique dessus. Si vous ne l'avez pas déjà fait, créez un ScreenGui avec un TextButton ou un ImageButton. Étant donné que seuls les clients voient ScreenGuis, utilisez toujours des scripts locaux dans ScreenGuis. Dans le bouton, insérez le code suivant dans un script local :

    • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts StarterGui
      • Tutoriel : Guide avancé sur les scriptsTutoriel : Guide avancé sur les scripts ÉcranGui
        • Tutoriel : Guide avancé sur les scripts Bouton de texte

    1 script.Parent.Activated:Connect(function() 2 print("Le bouton a été cliqué") 3 end)

    L'événement Activated se déclenche chaque fois que l'utilisateur appuie sur le bouton gauche de sa souris. Maintenant, il imprimera du texte chaque fois qu'il sera cliqué.

    Remarque : Ces scripts NE PEUVENT PAS être utilisés dans l'espace de travail. Rien ne se passera si vous essayez.

    joueur--joueur-contre-personnage-contre-humano-de">Objets Joueur : Joueur contre Personnage contre Humanoïde

    Une chose que vous devez comprendre avant de continuer est un joueur objet. Lorsqu'un joueur rejoint une partie, deux objets sont créés dans l'explorateur.

    Personnage

    Un modèle est créé dans l'espace de travail, qui gère l'apparence physique et les vêtements de votre corps. Il existe deux types de caractères : R6 (six articulations) ou R15 (quinze articulations.) C'est ce qu'on appelle le "caractère."

    Pour une utilisation future, voyons comment créer un caractère vide. Dans l'onglet Plugins, il y a une option appelée "Rig Builder". Choisissez le nombre de joints que vous voulez, et choisissez le type de personnage que vous voulez. Cela produira un caractère vide et gris dans l'espace de travail, également connu sous le nom de rig.

    Humanoïde

    Tous les joueurs recevront un objet humanoïde, qui est parent du personnage. Considérez-le comme une étiquette d'identification afin que vous puissiez vérifier si quelque chose est humain ou un PNJ. C'est pourquoi lorsque vous utilisez une kill brick, vous utilisez ce code :

    1 script.Parent.Touched:Connect(function(hit) 2 local hum = hit.Parent:FindFirstChild("Humanoid") 3 if hum then 4 hum.Health = 0 5 end 6 end)

    Cela vérifierait si hit.Parent (le personnage) a un objet humanoïde. Trouvons un moyen de faire bouger un PNJ. Pour une pièce normale, nous aurions besoin d'utiliser une boucle for pour la faire bouger. Pour les objets avec des humanoïdes, cependant, nous pouvons utiliser la fonction MoveTo pour le déplacer à un rythme normal.

    1 bourdonnement local = script.Parent.Humanoid 2 bourdonnement:MoveTo(game.Workspace.EndPart.Position)

    Cela déplacera l'humain vers la partie nommée "EndPart" dans l'espace de travail. Vous pouvez également utiliser des coordonnées comme celle-ci :

    1 bourdonnement local = script.Parent.Humanoid 2 bourdonnement:MoveTo(Vector3.new(x,y,z))

    N'oubliez pas que chaque fois que vous utilisez des coordonnées, vous devez soit utiliser CFrame.new ou Vector3.new.

    joueur

    Un objet joueur est un objet créé dans le service Players qui gère des éléments tels que l'ID du joueur et le sac à dos.

    Voyons donc comment trouver l'objet joueur correspondant à partir de son personnage. Nous utilisons la fonction GetPlayerFromCharacter() pour trouver l'objet joueur en saisissant le modèle de personnage.

    1 script.Parent.Touched:Connect(function(hit) 2 local plr = game.Players:GetPlayerFromCharacter(hit.Parent) 3 if plr ~= nil then 4 print(plr.Name) 5 end 6 end)

    Ce script tirerait le nom du joueur qui a touché la pièce.

    Comment trouver le personnage de l'objet joueur ? Il y a un Personnage propriété de l'objet Player qui afficherait le modèle de personnage correspondant.

    Événements à distance

    Donc, avec FilteringEnabled, que se passe-t-il si vous devez faire quelque chose comme faire apparaître un ScreenGui lorsqu'une partie est touchée ? Eh bien, ajoutez une télécommande. Il existe deux types de télécommandes : RemoteEvents et RemoteFunctions. Ce sont toutes des fonctions qui sont déclenchées côté client. Ils sont toujours stockés dans ReplicatedStorage. Pour déclencher un RemoteEvent, saisissez le code suivant :

    1 script.Parent.Touched:Connect(function(hit) 2 local Humanoid = hit.Parent:FindFirstChild("Humanoid") 3 si Humanoid alors 4 local player = game.Players:GetPlayerFromCharacter(hit.Parent) 5 game.ReplicatedStorage. RemoteEvent:FireClient(player) 6 end 7 end)

    Il y a donc beaucoup de nouveaux termes ici. « hit » fait référence à la partie qui a touché la partie ; dans ce cas, ce serait probablement le pied du joueur. hit.Parent fait référence au parent du pied, alias le personnage. La deuxième ligne vérifie si le personnage possède ou non un objet Humanoïde : en d'autres termes, elle vérifie si c'est un joueur qui a touché l'objet.

    La troisième ligne vérifie si la variable humanoïde est vraie ou fausse. Une valeur "false" est soit fausse, soit nulle, et tout le reste est une valeur véridique. Si l'humanoïde n'existe pas, la variable serait nulle ; par conséquent, ce serait une fausseté et ne remplirait pas la condition.

    Maintenant, insérez un script local dans StarterGui et entrez ce qui suit.

    1 game.ReplicatedStorage.OnClientEvent:Connect(function() 2 game.StarterGui.ScreenGui.Enabled = true 3 end)

    J'ai créé un écouteur, alias OnClientEvent, qui activerait le ScreenGui lorsque la partie est touchée.

    Fonctions à distance

    Les fonctions distantes ressemblent beaucoup aux événements distants, sauf qu'elles vous permettent de renvoyer une variable.

    Ainsi, au lieu de dire "FireClient", nous disons "InvokeClient".

    1 script.Parent.Touched:Connect(function(hit) 2 local Humanoid = hit.Parent:FindFirstChild("Humanoid") 3 si Humanoid alors 4 local player = game.Players:GetPlayerFromCharacter(hit.Parent) 5 game.ReplicatedStorage. RemoteFunction:InvokeClient (player) 6 end 7 end)

    De plus, l'auditeur dans StarterGui est un peu différent.

    1 fonction locale OpenGui() 2 game.StarterGui.ScreenGui.Enabled = true 3 end 4 game.ReplicatedStorage.RemoteFunction.OnClientInvoke = OpenGui

    Nous utilisons un signe égal au lieu d'une fonction Connect.

    Mais quelle est la différence entre InvokeServer et InvokeClient ? FireServer et FireClient ? Eh bien, lorsque vous souhaitez affecter quelque chose côté serveur à partir d'un script local (c'est-à-dire que vous souhaitez qu'un bloc apparaisse lorsque vous cliquez sur une interface graphique), vous utilisez Invoke/Fire Server. Lorsque vous souhaitez affecter quelque chose du côté client à l'aide d'un script serveur, utilisez Invoke/Fire Client.

    Parties d'un CFframe

    Un type de données que vous n'avez peut-être pas encore connu est un CFrame. Chaque partie a un CFrame. Chaque CFrame est composée de 12 chiffres. Les 3 premiers chiffres sont la position de la pièce. Les 9 autres valeurs sont pour la rotation, mais nous ne définissons pas ces valeurs directement. Voici comment définir la position et l'orientation d'une pièce :

    1 script.Parent.Position = Vector3.new(0,0,0) --Définit la position. 2 script.Parent.Position = CFrame.new(0,0,0) --Définit également la position. 3 script.Parent.Orientation = CFrame.Angles(0,math.rad(45),0) --Définit l'orientation.

    L'équipe de math.rad le convertisseur va convertir degrés à radians. Donc, si je devais dire math.rad(45), le système convertira 45 degrés en radians, environ 0.78 radians.

    Tutoriel : Guide avancé sur les scripts

    Un radian

    Pour être clair, un radian est une unité de mesure qui mesure environ 57.3°, soit un peu moins de 1/6 d'un cercle complet. Fondamentalement, c'est une petite tranche de pizza où tous les côtés sont les mêmes.

    Autres opérations mathématiques

    Vous connaissez peut-être les opérateurs arithmétiques de base, mais il en existe des plus avancés comme math.rad. Voici la plupart d'entre eux.

    • math.abs(x): trouve la valeur absolue de x
    • math.sin(x): trouve le rapport des sinus de x
    • math.cos(x): trouve le rapport cosinus de x
    • math.tan(x): trouve le rapport tangent de x
    • math.floor(x) : arrondit x au nombre entier inférieur le plus proche
    • math.ceil(x) : arrondit x au nombre entier supérieur le plus proche
    • math.rad(x) : convertit les angles en radians.
    • math.pow(x,y): trouve x^y.
    • math.sqrt(x) : trouve la racine carrée de x.
    • math.random(x,y): choisit un entier aléatoire entre x et y.
    • math.deg(x) : convertit les radians en degrés.

    Vous n'êtes peut-être pas familier avec beaucoup d'entre eux, mais vous les apprendrez plus tard en mathématiques au secondaire.

    Service du magasin de données

    L'une des dernières choses que vous devez apprendre pour créer un jeu entièrement fonctionnel est de sauvegarder les données des joueurs. Vous feriez cela en utilisant DataStoreService. Bien sûr, il n'apparaît pas dans l'explorateur, vous devez donc utiliser GetService().

    1 DataStoreService local = jeu:GetService("DataStoreService") 2 DataStore local = DataStoreService:GetDataStore("FirstDataStore")

    Un magasin de données est un endroit où les données sont stockées lorsque le lecteur est hors ligne. Lorsque vous utilisez la fonction GetDataStore(), le premier paramètre est le nom que vous donnez à la banque de données.

    Maintenant, nous devons réellement enregistrer les données du joueur. Réutilisons l'exemple Monopoly de la section leaderstats. Au bas de votre script, vous ajoutez un événement PlayerRemoving.

    1 game.Players.PlayerRemoving:Connect(function(player) 2 local UserID = "Player_"..player.UserId 3 local Cash = player.leaderstats.Cash 4 DataStore:SetAsync(UserID,Cash) 5 end

    Quelques nouveaux termes ici. Lorsque vous placez deux points entre deux types de données, vous les « concaténez », c'est-à-dire les former ensemble en une seule chaîne. La fonction SetAsync enregistre les données du lecteur dans le magasin de données.

    Cependant, il y a un problème. L'enregistrement des données du joueur est un processus risqué, et des choses comme une mauvaise connexion pourraient casser le script. Donc, pour éviter que cela ne se produise, il est important de placer une fonction pcall dans le script. Cela entraînerait le script à ignorer le code en cas d'échec et à continuer.

    1 game.Players.PlayerRemoving:Connect(function(player) 2 local UserID = "Player_"..player.UserId 3 local Cash = player.leaderstats.Cash 4 local Success, Failure = pcall(function() 5 DataStore:SetAsync( UserID,Cash) 6 end) 7 if Success puis 8 print("Données stockées avec succès") 9 else 10 print("Echec") 11 end 12 end)

    Permettez-moi d'expliquer. "Success" est un booléen et "Failure" est le message d'erreur en cas d'échec. Si le magasin de données enregistre avec succès, Success sera défini sur true. Il remplira la condition de l'instruction if en dessous et affichera "Données enregistrées avec succès".

    Si la sauvegarde des données a échoué, que ce soit à cause d'une mauvaise connectivité ou autre, Success deviendra faux et ne remplira pas la condition de l'instruction if ci-dessous. La fonction warn() est comme la fonction print(), sauf qu'elle s'imprime en orange. Il imprimerait donc le message d'erreur en orange en cas d'échec de la sauvegarde des données.

    Techniques de débogage de base

    Lorsque vous créez des scripts, vous rencontrerez inévitablement des bogues. Ce sont des erreurs dans votre code qui donnent un résultat inattendu. L'important est de ne pas abandonner, car tous les bugs sont, d'une manière ou d'une autre, résolvables. Il existe trois principaux types de bogues.

    Erreurs de syntaxe

    Les erreurs de syntaxe sont des bogues mineurs, généralement faciles à corriger, qui se produisent chaque fois qu'un joueur fait accidentellement des fautes de frappe dans le script. En anglais, ce serait comme dire "Je suis un garçon". C'est faux, car l'article est manquant. Dans Roblox Lua, ce serait comme le script ci-dessous. Voyez si vous pouvez détecter ce qui ne va pas dans ce script :

    1 script.Parent.Touched:Connect(function(hit) 2 print("Part Touched") 3 end

    Dans ce code, si vous remarquez, la balise de fin n'a pas de crochet fermant. Ceux-ci sont importants pour les événements.

    1 humanoïde local = hit.Parent.FindFirstChild("Humanoïde")

    En supposant que « hit » était le paramètre d'un événement Touché, ce code vérifie si la chose qui a touché la pièce était humaine ou non. Vous remarquerez cependant qu'après "Parent", il y a un point. FindFirstChild est une fonction, elle doit donc avoir un deux-points, pas un point.

    Erreurs sémantiques

    Ceux-ci sont légèrement plus difficiles à attraper. Ceux-ci se produisent lorsque la syntaxe est correcte, mais dans le contexte, le code n'a aucun sens. En anglais, ce serait comme dire "Je suis une université à un professeur". Bien que ce soit grammaticalement correct, cela n'a toujours aucun sens. Voici un exemple qui essaie de rendre Part1 invisible.

    1 jeu.Workspace.Part1.Tranparency = "lol"

    Cela ne fonctionne pas, car la propriété Transparency est une valeur flottante, pas une chaîne. De plus, Transparence n'est pas correctement orthographié.

    Les erreurs d'exécution

    Ces derniers sont plus difficiles à attraper. Celui-ci se produit lorsque le script est parfaitement logique, mais pour une raison quelconque, il ne peut toujours pas effectuer l'opération. L'exemple le plus célèbre d'erreur d'exécution est celui-ci :

    1 impression (1 / 0)

    Il est mathématiquement impossible de diviser 1 par 0, le système ne peut donc pas l'imprimer. Voici un exemple plus spécifique à Roblox :

    1 script.Parent.Touched:Connect(function() 2 game.StarterGui.InventoryGui.Enabled = true 3 end)

    À première vue, aucune erreur n'apparaît. Cependant, rien ne se passera si vous touchez la pièce et vous ne recevrez pas de message d'erreur. C'est à cause de FilteringEnabled, vous ne pouvez pas faire apparaître l'interface graphique sur un script de serveur. Le jeu refusera simplement d'effectuer l'opération.

    Contrôles de syntaxe automatisés

    Le plus souvent, si vous avez une erreur de syntaxe/sémantique dans votre script, le système la trouvera automatiquement et l'erreur spécifique sera surlignée en rouge ou en bleu. Survolez ces mots pour afficher une infobulle avec une brève explication.

    Donc, si vous deviez taper ce code :

    1 db local =

    La ligne serait soulignée en rouge ou en bleu, et le survol du texte dirait ceci : Instruction incomplète : affectation attendue ou appel de fonction. Pour corriger le bogue, vous devez attribuer une valeur ou supprimer le signe égal.

    La fenêtre de sortie

    Parfois, vous ne remarquez tout simplement pas l'erreur au premier coup d'œil et entrez dans le jeu sans la réparer. Ainsi, vous obtiendriez du texte en rouge et en gras dans la fenêtre de sortie expliquant l'erreur. En cliquant sur le message, vous accédez directement au script avec la ligne d'erreur en surbrillance.

    Imprimer les relevés

    Parfois, la fenêtre de sortie n'affichait rien, même si le script ne s'exécutait pas correctement. Disons que je voulais entrer ce code :

    1 local IntValue = script.Parent.IntValue 2 if IntValue >= 1 then 3 print("IntValue est supérieur à 1") 4 end)

    Le code ne s'imprimerait pas, même si IntValue était supérieur à 1. C'était peut-être quelque chose dans la première ligne qui ne fonctionnait pas correctement. L'ajout d'une instruction print comme celle-ci testerait si la première ligne a fonctionné :

    1 local IntValue = script.Parent.IntValue 2 print(1) 3 si IntValue >= 1 alors 4 print("IntValue est supérieur à 1") 5 end)

    Testez le jeu. Vous pouvez voir "1" affiché dans la fenêtre de sortie, donc la ligne 1 a fonctionné sans erreur. Cela signifie que l'erreur était dans la ligne suivante. L'utilisation d'instructions print permet d'identifier la ligne contenant une erreur.

    Le hub des développeurs

    Le hub des développeurs est un dépositaire d'informations sur tout ce qui concerne Roblox Studio. Si vous n'êtes pas sûr de la cause de l'erreur, essayez de rechercher les concepts dans le hub des développeurs.

    Disons que je n'ai aucune idée des paramètres que je dois inclure dans une fonction TweenService:Create(). Ensuite, je chercherais la fonction pour trouver la page spécifique, puis je trouverais la section des paramètres. Il inclurait les paramètres, le type de données des paramètres et ce qu'il renvoie.

    C'est donc un outil très utile pour trouver des solutions à vos bugs.

    Le forum de développement

    Mais que se passe-t-il si le hub s'avère trop technique pour que vous le compreniez ? Contrairement aux forums généraux, les forums de développeurs existent à ce jour, pour les développeurs cherchant à résoudre leurs propres questions de programmation et celles des autres. Si vous rencontrez un bogue, il y a de fortes chances que d'autres l'aient rencontré. Recherchez le message d'erreur et consultez les forums pour voir si quelqu'un d'autre a résolu votre problème pour vous.

    Disons que vous vous demandez pourquoi vous ne pouvez pas voir un TextLabel sur un SurfaceGui à travers une fenêtre. Recherchez-le et vous constaterez rapidement que vous pouvez résoudre le problème simplement en changeant le matériau de la fenêtre et/ou en augmentant la transparence.

    Le devforum n'est pas le seul forum pour les problèmes de script. Par exemple, si vous devez publier et que vous n'avez pas encore obtenu le rang de membre, il vous suffit d'aller sur scriptinghelpers.org, où vous pouvez publier tant que vous associez votre compte Roblox.

    Messages d'erreur courants

    Parfois, les messages d'erreur donnés dans la fenêtre de sortie sont extrêmement cryptiques et peu descriptifs, voici donc un guide rapide qui explique ce que signifient certains messages d'erreur.

    x attendu, obtenu y

    Ce message d'erreur apparaît chaque fois que vous faites une simple erreur de syntaxe. Cela peut se produire si vous utilisez une mauvaise ponctuation ou utilisez un type de données non valide dans une instruction. Donc si je devais taper ceci :

    1 script.Parent.Position = faux

    Le code ne fonctionnerait pas, car la propriété Position est un type de données Vector3 ou CFrame, mais false est un booléen. Ainsi, la sortie afficherait "Vecteur attendu 3, obtenu booléen". Corrigez cela en remplaçant "false" par des coordonnées.

    X n'est pas un membre valide de Y

    Cette erreur se produit si le serveur n'a pas pu trouver l'objet ou la propriété en cours d'accès avec le chemin. Donc, si je devais insérer ce script dans un modèle, cela ne fonctionnerait pas :

    1 script.Parent.Position = Vector3.new(1,4,4)

    Cela ne fonctionnera pas, car si vous regardez dans la fenêtre Propriétés, vous verrez qu'il n'y a pas une telle propriété qui modifie sa position. Vous devrez scripter chaque partie individuellement ou utiliser une WeldConstraint.

    Cela peut également être dû à des fautes d'orthographe dans votre script.

    Argument x manquant ou nul

    Cette erreur se produit lorsque vous, dans une fonction, omettez un paramètre nécessaire. Si je devais insérer ceci dans l'espace de travail :

    1 jeu. Espace de travail : FindFirstChild()

    Le code ne fonctionnerait pas, car je n'ai pas encore donné à la fonction quelque chose à rechercher. Ainsi, le code ne saura pas quoi rechercher, donnant une erreur.

    Rendement infini possible sur x

    Cela se produit lorsque vous utilisez une fonction de rendement qui est censée trouver quelque chose qui n'a pas encore été chargé. Par exemple:

    1 jeu. Espace de travail : WaitForChild ("Roue")

    Si Wheel n'existe pas, le script imprimera l'erreur en orange et attendra qu'elle existe. Il pourrait finir par attendre indéfiniment son chargement, donc tout code en dessous ne fonctionnera pas.

    Instruction incomplète : affectation ou appel de fonction attendu

    Cela se produit lorsqu'une partie d'une ligne est manquante.

    1 local Existe =

    Vous pouvez voir que je n'ai pas attribué de valeur à Var, mais j'ai inclus un signe égal. Cela créerait une erreur. Si vous souhaitez définir Var sur nil, excluez le signe égal.

    Et c'est tout ce que vous devez savoir pour créer votre premier jeu fonctionnel ! Si vous avez besoin de compétences supplémentaires, consultez le tutoriel Expert Scripting.

    Exemples

    Blocage du joueur de coup de pied

    Ce didacticiel donnera un coup de pied à un joueur chaque fois qu'il touchera une partie. Encore une fois, vous ne pouvez pas utiliser de scripts locaux dans l'espace de travail, utilisez donc un RemoteEvent.

    1 script.Parent.Touched:Connect(function(hit) 2 local Humanoid = hit.Parent:FindFirstChild("Humanoid") 3 si Humanoid alors 4 local player = game.Players:GetPlayerFromCharacter(hit.Parent) 5 game.ReplicatedStorage. RemoteEvent:FireClient(player) 6 end 7 end)

    Ensuite, créez un écouteur dans StarterGui à l'aide d'un script local.

    1 jeu.ReplicatedStorage.OnClientEvent:Connect(function() 2 game.Players.LocalPlayer:Kick("lol") 3 end)

    Ici, j'utilise une fonction Kick() pour expulser le joueur du jeu. Le LocalPlayer est le joueur qui a déclenché l'événement. Dans une fonction Kick(x), le paramètre x représente la raison du coup de pied du joueur.

    Générateur de grenades

    Ce tutoriel montrera comment faire apparaître et exploser une grenade fonctionnelle lorsqu'on clique sur une pièce.

    1 anti-rebond local = false 2 GrenadeSpawner local = script.Parent 3 GrenadeSpawner.ClickDetector.MouseClick:Connect(function() 4 si anti-rebond == false alors 5 anti-rebond = vrai 6 Grenade locale = Instance.new ("Part") 7 Grenade. Taille = Vector3.new(1,2,1) 8 Grenade.Parent = game.Workspace 9 Grenade.Position = Vector3.new(1,1,1) 10 11 Local TextureMesh = Instance.new("SpecialMesh") 12 TextureMesh .Parent = Grenade 13 TextureMesh.TextureId = "rbxassetid://290930193" 14 TextureMesh.MeshId = "rbxassetid://294740282" 15 16 wait(1) 17 local Explode = Instance.new("Explosion") 18 Explode.Parent = Grenade 19 Grenade:Destroy() 20 debounce = false 21 end 22 end)

    Dans ce script, lorsque GrenadeSpawner est cliqué, il créera une pièce. Ensuite, il créera un SpecialMesh, qui le fera ressembler à une véritable grenade. Bien sûr, vous devrez modifier les ID d'actif.

    Ensuite, il attendra 1 seconde avant d'exploser et de détruire la grenade. Debounce n'est là que pour s'assurer qu'une seule grenade peut exister à la fois pour éviter le spam.

    ajouter un commentaire de Tutoriel : Guide avancé sur les scripts
    Commentaire envoyé avec succès ! Nous l'examinerons dans les prochaines heures.