Catégorie : ROBLOX

Créer un OBBY

Un « obby » (course d’obstacle) est un type de jeu sur Roblox où les joueurs doivent traverser une série d’obstacles pour atteindre la fin. Voici un guide pour créer votre propre obby avec des critères spécifiques et des instructions détaillées pour chaque partie.

Critères :

1. Avoir au minimum 10 niveaux différents : Votre obby doit comporter au moins 10 niveaux uniques.
2. Respecter toutes les parties : Suivez toutes les instructions pour chaque partie.
3. Ne pas utiliser la tool-box pour les scripts ou certains obstacles : Évitez d’utiliser la tool-box pour les scripts et certains obstacles.
4. Avoir au minimum un script spécial : Incluez au moins un script spécial dans votre obby.

---

Partie I : Créer le Lobby

Objectif : Créer un lobby (zone de départ) où le joueur apparaîtra et le décorer.

Instructions :

1. Créer le lobby : Utilisez des « parts » (blocs) pour créer un espace où le joueur apparaîtra au début du jeu.
2. Décorer le lobby : Ajoutez des éléments décoratifs pour rendre le lobby attrayant.

Suggestion pour la suite

Pour t’aider, oublie pas d’utiliser la fenêtre de sortie et la possibilité de mettre des commentaires dans ton script :

Commentaire d’une ligne :

–print(« instruction en commentaire »)

Commentaire de plusieurs instructions :

–[[
print(« instruction en commentaire »)
print(« instruction en commentaire »)
–]]

---

Partie II : Niveau 1 du jeu – Système de Déplacement de Part par un menu

Objectif : Créer un système pour déplacer une part à droite et à gauche pour aider le joueur à finir le premier niveau.

Instructions :

1. Créer une part : Ajoutez une part et renommez-la.
2. Créer un « Screen Gui » : Dans « StarterGui », ajoutez un « Screen Gui » et placez une « Frame » à l’intérieur.
3. Système d’ouverture/fermeture : Créez deux boutons pour ouvrir et fermer la « Frame ».
4. Boutons de déplacement : Ajoutez deux boutons pour déplacer la part à droite et à gauche.
   • Indice : Utilisez [nom de la variable de la part].Position += Vector3.new(x, y, z) pour déplacer la part.

Comment indiquer une ressource dans un script :

local btOpenMenu = script.Parent.OpenButton

Comment détecter un click de la souris sur un bouton :

btOpenMenu.MouseButton1Click:Connect(function()

end)

Comment déplacer un objet Roblox :

myPart.Position += Vector3.new(10,0,0)

Gérer les niveaux, afficher dans le chat du joueur son niveau :

Rajouter un script ChatScript sous ReplicatedStorage :

Puis coder dans ce script :

local ChatScript = {}

function ChatScript.sendMessage(player, message)

local character = player.Character or player.CharacterAdded:Wait()
if character then
    local head = character:WaitForChild("Head") 
    if head then
        game:GetService("Chat"):Chat(head, message) 
    end
end

end

return ChatScript

Rajouter dans votre script qui gère votre interface les instructions suivantes lorsque le joueur referme la fenêtre :

local chat = require(game.ReplicatedStorage.ChatScript)

chat.sendMessage(player, "niveau : 1")

---

Partie III : Niveau 2 – Parts Mobiles

Objectif : Faire en sorte qu’une ou plusieurs parts bougent continuellement.

Instructions :

1. Ajouter des parts mobiles : Dans un de vos niveaux, ajoutez des parts qui bougent.
   • Indice : Utilisez while true do et for i = 1, x do pour créer un mouvement continu.

Déplacer un objet x fois :

for i = 1, 50 do
maPart.Position += Vector3.new(5,0,0)
wait(1)
end

Déplacer un objet Roblox tout le temps :

while true do
maPart.Position += Vector3.new(0.05,0,0)
wait(0.01)
end

Déplacer un objet jusqu’à une position :

while maPart.Position.X<60 do
maPart.Position += Vector3.new(5,0,0)
wait(0.01)
end

Synchroniser le déplacement avec le moteur de Roblox :

game:GetService(« RunService »).Heartbeat:Connect(function()
maPart.Position += Vector3.new(0.05,0,0)
end)

Exercer une force sur le part pour le bouger :

part.Anchored = false

local linearVelocity = Instance.new(« LinearVelocity »)
linearVelocity.Attachment0 = part:FindFirstChildOfClass(« Attachment ») or Instance.new(« Attachment », part)
linearVelocity.MaxForce = 20000 — Définir la force maximale
linearVelocity.VectorVelocity = Vector3.new(0, 0, 50) — Définir la vitesse linéaire
linearVelocity.Parent = part

wait(1) — Attendre 5 secondes

linearVelocity:Destroy()
part.Anchored = true

---

Partie IV : Niveau 3 – Part Mortel

Objectif : Créer une part qui tue le joueur lorsqu’il la touche.

Instructions :

1. Créer un part rouge : Ajoutez un part, colorez-le en rouge et utilisez le matériau « Néon ».

1. Ajouter un script : Créez un script dans le part.
2. Script de mort : Lorsque le joueur touche le part, il meurt.
   • Indices :
     • Utilisez [Nom du part].Touched:Connect(function(player) pour détecter le contact.
     • Utilisez character = player.Parent pour obtenir le personnage du joueur.
     • Utilisez humanoid = character and character:FindFirstChild("Humanoid") pour obtenir l’objet Humanoid du joueur.
     • Tuer le joueur : humanoid.Health = 0

Santé du joueur à 100 au départ du jeu :

print(humanoid.Health)

Réduire la santé du joueur :

humanoid.Health = humanoid.Health – 5
ou
humanoid:TakeDamage((5))

Le joueur meurt quand sa santé est à zéro :

humanoid.Health = 0

---

Partie V : Niveau 4 – Part Invisible

Objectif : Créer un part invisible qui apparaît lorsque le joueur clique sur un autre part.

Instructions :

1. Créer un part avec ClickDetector : Ajoutez un part, renommez-la, et ajoutez un « ClickDetector ».
2. Créer un part invisible : Ajoutez un autre part et définissez Transparency = 1 et CanCollide = false.
3. Script d’apparition : Lorsque le joueur clique sur le part avec le « ClickDetector », le deuxième part apparaît.
   • Indices :
     • Utilisez [Premièr Part].ClickDetector.MouseClick:Connect(function() pour détecter le clic.
     • Utilisez [Créez ta variable] = [Nom de la part où on click]:WaitForChild("ClickDetector") pour obtenir le ClickDetector.

Comment coder un ClickDetector sur le part :

local clickDetector = script.Parent.ClickDetector

clickDetector.MouseClick:Connect(function()
print(« touché »)
end)

Comment coder un Prompt :

maPart.ProximityPrompt.Triggered:Connect(function(otherPart)
print(‘activé’)
end)

Script pour rendre visible/invisible un part :

local clickDetector = script.Parent.ClickDetector
local level1 = workspace.Pathfinding.Level01

level1.Part01.Transparency = 1
level1.Part01.CanCollide = false

clickDetector.MouseClick:Connect(function()
if level1.Part01.Transparency == 1 then
level1.Part01.Transparency = 0
else
level1.Part01.Transparency = 01
end
level1.Part01.CanCollide = not level1.Part01.CanCollide
end)

Script pour faire apparaître/disparaître un niveau de jeu :

local clickDetector = script.Parent.ClickDetector
local level1 = workspace.Pathfinding.Level01

for , level in level1:GetChildren() do
level.Transparency = 1
level.CanCollide = false
end

clickDetector.MouseClick:Connect(function()
for _, level in level1:GetChildren() do
level.Transparency = level.Transparency == 1 and 0 or 1
level.CanCollide = not level.CanCollide
end
end)

---

Partie VI : Pathfinding (recherche de chemin) avec des Parts

Objectif : Créer un chemin de parts où le joueur doit sauter au bon moment pour passer à la prochaine part.

Instructions :

1. Créer 3 parts : Ajoutez des parts et renommez-les.
2. Créer un patherme : Disposez les parts de manière à ce que le joueur doive sauter au bon moment pour passer à la suivante.
   • Indice : Utilisez la Transparency pour rendre certaines parts invisibles.
   • Indice : supprimer l’objet baseplate

Exemple de Pathfinding avec deux niveaux :

Exemple pour passer à un niveau 2 :

Exemple de script pour faire apparaître le niveau 2 lors du clic sur le ClickDetector:

local clickDetector = script.Parent.Level01.ArrowToLevel02.ClickDetector

— récupération de tous les parts du niveau 2
local levels = script.Parent.Level02:GetChildren()

— récupération du système de chat
local chat = require(game.ReplicatedStorage.ChatScript)

clickDetector.MouseClick:Connect(function(otherPart)

-- envoie du message au chat du joueur
chat.sendMessage(otherPart, "niveau : 2")

-- rendre visible tous les objets du niveau 2 
for _, level in levels do
    level.Transparency = 0
end

end)

---

Partie VII : Labyrinthe avec Portes Temporisées

Objectif : Créer un labyrinthe avec des portes qui s’ouvrent temporairement.

Instructions :

1. Créer un labyrinthe : Utilisez des parts pour créer un labyrinthe.
2. Ajouter une porte : Ajoutez une part et renommez-la.
3. Créer un bouton : Ajoutez une autre part qui servira de bouton.
4. Script de porte temporisée : Lorsque le joueur appuie sur le bouton, il a un nombre de secondes « x » pour passer la porte, sinon elle se referme.
   • Condition : La porte doit s’ouvrir soit vers les côtés, soit vers le haut en animation.
5. Ajouter 3 portes : Créez au moins 3 portes comme cela dans le même script.

Créez une porte à partir d’un part :

Rangez le part et renommez le dans l’explorateur :

Puis créez avec un part une poignée :

Créez une contrainte rigide entre la porte et la poignée :

Sélectionnez la poignée puis la porte puis demande une « soudure » entre les deux éléments :

Demandez un clickDetector sur la poignée :

Modifiez le pivot de la porte :

Créez un script pour ouvrir la porte :

local clickDetector = script.Parent.Handle.ClickDetector
local door = script.Parent.Door

local function doorRotation(door, push, rotation)
if push ~= 0 then
for i = 1, (rotation//math.abs(push)) do
door:PivotTo(door:GetPivot() * CFrame.Angles(math.rad(push), 0, 0))
wait(0.01)
end
end

end

clickDetector.MouseClick:Connect(function()
doorRotation(door, 1, 90)
end)

Refermez la porte au bout de x secondes, rajouter ces deux instructions :

task.wait(5)
doorRotation(door, -1, 90)

Modifier le script pour déplacer la porte vers le haut :

local clickDetector = script.Parent.Handle.ClickDetector
local door = script.Parent.Door

local distance = clickDetector.MaxActivationDistance

local function doorPushUp(door, push)
door.CFrame += Vector3.new(0,push,0)
while door.CFrame.Position.Y>5 and door.CFrame.Position.Y<15 do
wait(0.01)
door.CFrame += Vector3.new(0,push,0)
end
end

clickDetector.MouseClick:Connect(function()
clickDetector.MaxActivationDistance = 0
doorPushUp(door, 1)
task.wait(5)
doorPushUp(door, -1)
clickDetector.MaxActivationDistance = distance

end)

---

Partie VIII : Menu de départ du jeu

Objectif : Créez un menu pour le lancement du jeu

Instructions :

1. Créer un menu de lancement du jeu : Afficher le titre du jeu et un bouton PLAY.
2. Créer un script de démarrage : Lancer le jeu par le bouton play.

Créez un menu de démarrage du jeu :

Crée un script pour afficher le menu et lance le jeu :

---

Partie IX : Animation glissade du joueur

Objectif : Crée une animation de glissade

Instructions :

Créer une animation : Lancer le jeu par le bouton play.

Créer un script pour lancer l’animation sur l’appuie d’une touche du clavier 

Choisis AVATAR puis constructeur de RIG

Choisis ton RIG :

R6 : Moins de parties mobiles, mouvements moins fluides, apparence plus simple.

R15 : Plus de parties mobiles, mouvements plus fluides et réalistes, apparence plus détaillée.

Déplace ton RIG pour créer l’animation

Ouvre l’éditeur d’animation :

L’éditeur d’animation ouvre une Timelapse :

Une timelapse dans un éditeur d’animation est une technique qui permet de capturer et de montrer le processus de création d’une animation. Cela signifie que vous enregistrez votre travail à intervalles réguliers et ensuite vous compilez ces enregistrements en une vidéo qui montre l’ensemble du processus de l’animation.

Demande à créer l’animation sur l’ensemble du corps en appuyant sur le + :

Décoche Rotation et Déplacer

Modifie les positions du corps étape par étape pour animer une glissade :

Définis la priorité de l’animation :

Action2 : Utilisé pour les animations qui doivent avoir la priorité sur les animations d’inactivité et de mouvement, mais pas nécessairement sur les animations de haute priorité.

Sauvegarde l’animation et garde bien sa référence car tu vas en avoir besoin :

Copie la référence de l’animation :

Garde bien l’identifiant puis ferme la fenêtre:

---

Script de l’animation

Crée un localscript sous StarterPlayer dans StarterCharacterScripts :

Puis une animation :

Modifie les noms du script et de l’animation :

Tu peux maintenant coller la référence de l’animation dans AnimationId de ton animation :

Code du script pour lancer l’animation

Code ton script pour que l’animation se lance sur une touche du clavier, dans l’exemple la touche CTRL :

local UIS = game:GetService(« UserInputService »)

UIS.InputBegan:Connect(function(input, gpe)
if gpe then return end
if input.KeyCode == Enum.KeyCode.LeftControl then
print(« animation glissade »)
end
end)

Vérifie que tu as le message dans la sortie lorsque tu appuies sur CTRL

Code pour lancer l’animation dans une fonction et que tu ne puisses pas la lancer plusieurs fois :

local in_progress = false
local function ActivationGlissade()
if not in_progress then
in_progress = true
print(« animation glissade »)
task.wait(1)
in_progress = false
end
end

UIS.InputBegan:Connect(function(input, gpe)
if gpe then return end
if input.KeyCode == Enum.KeyCode.LeftControl then
ActivationGlissade()
end
end)

Code pour lancer l’animation :

local UIS = game:GetService(« UserInputService »)

local Character = script.Parent
local Humanoid = Character:WaitForChild(« Humanoid »)
local GlissadeAnimation = Humanoid:LoadAnimation(script:WaitForChild(« GlissadeAnimation »))

local in_progress = false

local function ActivationGlissade()
if not in_progress then
in_progress = true
GlissadeAnimation:Play()
task.wait(1)
in_progress = false
end
end

Ton animation se lance mais ne s’arrête plus :

local function ActivationGlissade()
if not in_progress then
in_progress = true
GlissadeAnimation:Play()

local humanoidRootPart = Character:WaitForChild(« HumanoidRootPart »)
local linearVelocity = Instance.new(« LinearVelocity »)
linearVelocity.Attachment0 = Instance.new(« Attachment », humanoidRootPart)
linearVelocity.MaxForce = 10000 — Définir la force maximale
linearVelocity.VectorVelocity = Character.HumanoidRootPart.CFrame.LookVector * 30
linearVelocity.Parent = Character.HumanoidRootPart

task.wait(1)

GlissadeAnimation:Stop()
linearVelocity:Destroy()
in_progress = false

end
end

Modifie ton code pour paramétrer le temps de l’animation et sa vitesse :

–Modifications de la fonction avec deux paramètres
local function ActivationGlissade(sliding_time, speed)

Humanoid.WalkSpeed = speed

linearVelocity.VectorVelocity = Character.HumanoidRootPart.CFrame.LookVector * speed
task.wait(sliding_time)

–Modifications de l’appel de la fonction temps de l’animation et vitesse
ActivationGlissade(0.5,10)

---

Partie X : Tableau de scores

Objectif : Créé un tableau de scores

Créer un script pour afficher un tableau de score au joueur sous ServerScriptService :

Renommer le script leaderstats :

Saisir le code suivant pour un affichage d’une barre de scores :

local players = game:GetService(« Players »)

players.PlayerAdded:Connect(function(player)
local leaderstats = Instance.new(« Folder »)
leaderstats.Name = « leaderstats »
leaderstats.Parent = player
end)

Si tu lances ton jeu une barre s’affiche :

Rajoute à ton script un score à afficher :

local players = game:GetService(« Players »)

players.PlayerAdded:Connect(function(player)

local leaderstats = Instance.new(« Folder »)
leaderstats.Name = « leaderstats »
leaderstats.Parent = player

local score = Instance.new(« IntValue »)
score.Parent = leaderstats
score.Name = « Score »
score.Value = 0

end)

Le score s’affiche si tu lances ton jeu :

Exemple d’un script pour augmenter le score si le joueur click sur un ClickDetector :

local clickDetector = script.Parent.ClickDetector

clickDetector.MouseClick:Connect(function(player)

player:WaitForChild(« leaderstats »).Score.Value += 10

end)

---

Partie XI : Crée une boutique

Objectif : Créé une boutique avec des objets à acheter

Crée un bouton et une fenêtre pour ta boutique sous StarterGUI :

Pout ta boutique crée :

• un bouton pour ouvrir et fermer la fenêtre de ta boutique
• une fenêtre avec un titre
• un localscript pour gérer l’ouverture de ta boutique

Ton script :

Modifie sous ServerScriptService le script leaderstats pour gérer un portemonnaie numérique :

Modifie ta boutique pour proposer l’achat d’une torche par l’ajout d’un TextButton:

L’objectif est de placer la torche achetée dans la boutique dans le BackPack du joueur. Le Backpack est principalement utilisé pour contenir des outils que les joueurs peuvent s’équiper et utiliser. Ces outils peuvent être des objets interactifs, des armes, ou tout autre objet qui peut être utilisé pour interagir avec le monde du jeu.

• Le Backpack est principalement géré côté client. Chaque joueur a son propre Backpack, et les outils qu’il contient sont spécifiques à ce joueur.
• Bien que le Backpack soit géré côté client, les outils peuvent être ajoutés ou retirés par des scripts côté serveur en utilisant des RemoteEvents pour communiquer avec le client.
• ReplicatedStorage est souvent utilisé pour stocker des objets et des ressources qui doivent être partagés entre le serveur et les clients, ce qui en fait un endroit logique pour organiser les RemoteEvents.

Crée un RemoteEvent sur ReplicatedStorage :

Puis renomme le RemoteEvent :

Puis stocke une torche dans le ServerStorage.

ServerStorage offre un endroit organisé pour stocker les objets côté serveur, ce qui peut faciliter la gestion et la maintenance du code et des ressources du jeu.

Modifie le script du caddy pour prendre la torche :

Puis crée un script BuyShopService dans ServerScriptService pour ajouter la torche au BackPack :

Lance le jeu pour tester le résultat :

Achète la torche, on ne contrôle pas pour l’instant si tu disposes de suffisamment d’argent :

Maintenant contrôle si le joueur peut acheter la torche, modifie le script de ta boutique :

Puis pour tester, modifie la valeur de coins lorsque tu lances le jeu :

Au lieu de mettre l’objet dans BackPack, tu peux le mettre à disposition dans le Workspace :

Donne une position correcte à l’objet dans ServerStorage :

Ainsi que :

---

Partie XII : Modifie l’éclairage du jeu

Objectif : Modifier l’éclairage global du jeu

Propose à ton joueur de vivre une ambiance différente en :

• Modifiant le niveau de l’éclairage global.
• Modifiant l’heure de la journée.

Change l’éclairage global

L’éclairage global correspond à la luminescence du soleil ou de la lune.

• Dans la fenêtre de l’Explorateur , sélectionnez Lighting .
• Dans la fenêtre Propriétés , modifie le paramètre Brightness :

Changer l’heure de la journée

Change l’heure de la journée pour modifier l’éclairage global de ton jeu.

• Dans la fenêtre de l’Explorateur , sélectionnez Lighting .
• Dans la fenêtre Propriétés , modifie le paramètre ClockTime :

Jouer avec un script sur la luminosité :

Crée un nouveau RemoteEvent BrightnessEvent:

Crée un script BrightnessService sous ServerScriptService :

Puis dans le script saisie le programme suivant :

Puis diminue la lumière dès que le joueur achète la torche :

---

Partie XIII : Téléportation

Objectif :

Tu vas utiliser la téléportation pour ton jeu mais également pour tester plus rapidement des phases de ton jeu. Tu pourras mettre ainsi une téléportation pour déplacer ton joueur dans une zone à tester sans avoir à parcourir tout le jeu.

Mise en place des points de téléportation

Dans Workspace crée un nouveau model :

Que tu renommes Teleports :

Puis crée deux bocs :

Que tu glisses sous Teleports et renommes en TeleportA et Teleport B :

Modifie la couleur :

Modifie la taille :

Puis modifie ce paramètre :

Puis place dans ton jeu les deux points de téléportation, le point A près de ton joueur au lancement du jeu, puis le point B à l’endroit d’arrivée de ton joueur.

Programme ta première téléportation

Puis viens créer un nouveau script sous Teleleports :

Renomme le nouveau script en TeleportService :

Puis écris le programme suivant dans le script TeleportService :

Sur le model Teleports crée la propriété deadlineOutside temps en seconde, cette propriété est utilisée pour indiquer le temps pour que le joueur puisse sortir du point de téléportation avant une nouvelle téléportation :

Puis pour chaque point de téléportation, crée une nouvelle propriété target pour indiquer le point de téléportation de destination :

Lance ton jeu et essaye la téléportation

---

Conclusion

En suivant ces instructions, vous serez en mesure de créer un obby complet et fonctionnel sur Roblox. Assurez-vous de respecter tous les critères et d’utiliser les indices pour vous aider à compléter chaque partie. Bonne chance et amusez-vous bien !

Ton objectif : parcourir les plateformes de plus en plus haute, pour cela tu dois attraper le plus de pièces pour obtenir plus de force de saut.

Voir un exemple du jeu que tu vas créé avec ce tutoriel : https://www.roblox.com/games/84021617795434/

Tu peux essayer ce jeu par exemple, l’expérience d’île de saut Island Jump – Scripting pour te montrer ce que tu peux réaliser.

Crée une île

Pour créer un projet avec le modèle Baseplate :

1. Dans la barre de navigation verticale, sélectionne « Modèles » . Tous les modèles s’affichent.
2. Sélectionnez le modèle « Baseplate » . Roblox Studio ouvre une nouvelle expérience :

Apprend maintenant à utiliser l’éditeur de terrain pour créer un environnement insulaire autour du lieu d’apparition, départ de ton futur jeu de plateformes.

Crée une île avec l’éditeur de création de terrain

Dans la barre de menu, accède à l’ onglet Accueil , puis clique sur le bouton Éditeur de terrain . La fenêtre Éditeur de terrain s’affiche :

Dans la fenêtre Éditeur de terrain , clique sur l’ onglet Editer, puis sur le bouton Dessiner :

Dans les sections Paramètres de la brosse et Paramètres du matériel , choisis les options suivantes  :

Règle la taille de la brosse :

• Puis choisi comme matériel l’herbe :

Puis dessine ton ile :

Sélectionne dans la fenêtre Explorateur sous Workspace : SpawLocation puis modifie sa position : y = 13

Si tu joues, tu parcours ton île dans l’herbe.

Mais ton île n’en n’est pas vraiment une, il manque l’eau autour.

Crée un océan autour de ton île, choisis dans l’éditeur de terrain l’outil Remplir puis modifie les Paramètres de sélection puis les Paramètres du matériel taille X : 4000 Y: 8 Z : 4000, position X : 0, Y : 4, Z : 0 :

Sélectionne Air dans le Matériel source :

Puis choisis dans le Matériel cible l‘Eau puis Remplacer :

Maintenant tu obtiens une vraie île, tu peux supprimer la Baseplate dans la fenêtre Explorateur:

Maintenant tu parcourir ton monde et prendre un bain :

Avant d’insérer des éléments d’espace réservé dans l’espace 3D, il est important de créer une structure d’organisation pour tes ressources dans le Workspace . Ce processus garantit que ton espace de travail reste organisé et facile à analyser.

Il existe deux types de conteneurs que tu peux utiliser pour regrouper des ressources : les objets Folder et Modèle . Les dossiers sont utiles pour stocker de nombreux objets de différents types, et les modèles sont utiles pour stocker des groupements géométriques de pièces similaires. Les instructions suivantes t’apprenne à utiliser les deux objets conteneurs pour stocker toutes les ressources de ton monde 3D.

Pour créer une structure organisationnelle :

1. Dans la fenêtre de l’Explorateur , passe la souris sur Workspace et cliquez sur l’ icône ⊕ . Un menu contextuel s’affiche.
2. Dans le menu contextuel, insérez un objet Folder :

Renomme le nouveau dossier « World » .

1. Clique avec le bouton droit sur l’objet dossier. Un menu contextuel s’affiche.
2. Dans le menu contextuel, clique sur Renommer et entrez World comme nom du dossier :

Puis crée une structure Model pour toutes tes plateformes :

Puis renomme ton Model en plateformes :

Maintenant que tu disposes d’une structure pour contenir tes plateformes, tu vas insèrer des éléments 3D pour représenter tes plateformes :

Pour insérer une pièce cylindrique pour ta première plateforme :

1. Dans la barre de menu, sélectionnez l’onglet Accueil .
2. Dans la section Elément Insérer , clique sur la flèche déroulante, puis sélectionnez Cylindre . Une pièce cylindrique s’affiche dans la fenêtre d’affichage :

Puis glisse le nouvel objet sous le Folder World :

Puis renomme l’objet cylindre :

Saisie la taille et la position de ta première plateforme :

Dans la fenêtre de l’Explorateur , sélectionnez le modèle Plateformes.

Dans l’ onglet Accueil , accédez à la section Modifier et cliquez sur l’icône Ancre . Cela garantit que le système physique ne déplace pas les plateformes lorsque l’on joue.

Tu peux vérifier :

Lance ton jeu et saute sur ta première plateforme :

Par un clique droit demande à dupliquer ta première plateforme, recommence l’opération pour obtenir trois plateformes :

Puis modifie la taille et la position des deux nouvelles plateformes :

Tu dois obtenir ce résultat :

Crée des pièces pour gagner de la force afin de pouvoir sauter

Avant de créer ton système de gain, tu dois créer un espace Model pour les pièces à gagner.

Dans la fenêtre de l’Explorateur , ajoute un nouveau Model dans le dossier World , puis renomme-le Coins .

Pour créer les pièces :

Insérez l’objet cylindre dans le dossier Coin , puis renommez en Coin :

Sélectionnez Coin, puis dans la fenêtre Propriétés ,

• Définissez BrickColor sur Or .
• Réglez le matériau sur Metal .
• Définissez la taille sur 0,1, 4, 2 .
• Désactivez CanCollide . Cela indique que le joueur peut traverser les pièces pour les récupérer.

Puis viens mettre ancre sur le model des pièces :

Duplique la pièce :

Puis déplace les pièces dans l’espace devant la première plateforme:

Tu peux essayer d’attraper les pièces :

Tu peux constater que tu ne peux pas attraper les pièces.

Pour que les pièces soient récupérables, tu dois programmer l’action lorsque le joueur les touche. Le moteur Roblox peut t’avertir lorsque quelque chose touche une pièce, mais tu dois le programmer dans un script.

Comment récupérer les pièces

Pour que les pièces soient récupérables, le moteur Roblox avertit lorsque quelque chose touche une pièce, mais tu avs le programmer dans un script. Pour créer un script :

Dans la fenêtre de l’Explorateur , sélectionne avec la souris
ServerScriptService et clique sur le bouton ⊕ . Un menu contextuel s’affiche :

Renomme le script :

Un nouvel onglet est ouvert, remplace le code par défaut par le code suivant :

Désormais, chaque fois qu’un joueur touche une pièce, le journal de sortie affiche « Pièce collectée par le joueur ».

Pour afficher le journal de sortie :

Attraper les pièces

Essaye maintenant d’attraper des pièces :

Tu constates le résultat dans la console de sortie.

Maintenant, chaque fois que le joueur touche une pièce, la pièce disparaît :

Stockage de la collecte des pièces

Pour gérer le stockage et la gestion des données de collection de pièces de chaque joueur, tu dois créer un objet ModuleScript contenant une structure de données et des fonctions qui accèdent aux données de collection de pièces de chaque joueur. Les scripts de module sont du code réutilisable dont d’autres scripts peuvent avoir besoin. Dans ce cas, CoinService a besoin de ce script de module pour pouvoir mettre à jour les données de collection de pièces lorsque les joueurs touchent des pièces.

Pour créer un script de module :

1. Dans la fenêtre de l’Explorateur , passez la souris sur ServerStorage et cliquez sur le bouton ⊕ . Un menu contextuel s’affiche.
2. Dans le menu contextuel, sélectionnez ModuleScript . Un nouveau script de module s’affiche sous ServerStorage. Renomme le en PlayerData :

Remplacez le code par défaut par le code suivant :

Une fois le script  PlayerData terminé, appelle ce dernier dans le script CoinService pour mettre à jour le nombre de pièces récoltées :

1. Dans la fenêtre de l’Explorateur , ouvrez le script CoinService .
2. Modifie le code existant par le code suivant :

Les modifications apportées au script CoinService d’origine incluent :

• Importation des modules PlayerData avec la fonction require() .
• Déclarer COIN_AMOUNT_TO_ADD comme le nombre de pièces à ajouter lorsqu’un joueur collecte une pièce, et COIN_KEY_NAME comme le nom de clé défini dans PlayerData .
• Création de la fonction updatePlayerCoins() pour mettre à jour le nombre de pièces récoltées par le joueur.
• Remplacement de l’ instruction print() dans onCoinTouched() par un appel à updatePlayerCoins() .

La table playerData contient des commentaires qui décrivent la structure de la table, ce qui facilite la compréhension du code. Dans ce cas, une 
table playerData contient un userId et un champ correspondant nommé 
Coins qui représente le montant des pièces collectées pour ce joueur.

Lance le jeu pour vérifier le comptage des pièces récoltées :

Affichage de la collecte des pièces

Maintenant, tu peux représenter visuellement les données de collecte de pièces avec un classement à l’écran. Roblox comprend un système intégré qui génère automatiquement un classement à l’aide d’une interface utilisateur par défaut.

Pour créer le classement :

Dans la fenêtre de l’Explorateur , crée un ModuleScript dans ServerStorage puis renommez le script du module en Leaderboard .

Remplacez le code par défaut par le code suivant :

Une fois le script  PlayerData terminé, appelle ce dernier dans le script CoinService pour mettre à jour le nombre de pièces récoltées :

1. Dans la fenêtre de l’Explorateur , ouvrez le script CoinService .
2. Modifie le code existant par le code suivant :

Lance le jeu pour vérifier l’affichage du score du joueur :

Le joueur part sans force de saut et doit gagner sa force de saut en attrapant les pièces pour pouvoir monter sur les plateformes :

Le joueur perd sa faculté de sauter

Crée un moduleScript pour modifier la force de saut du joueur :

Renomme le module script en PlayerModule puis saisie le code suivant :

Puis modifie le script CoinService :

Puis rajoute en fin du script CoinService :

Joue et essaye de sauter

Redonner la force de sauter au joueur

Ton joueur ne peut plus sauter !! Tu dois lui redonner de la force de saut en attrapant les pièces, modifier le script CoinService :

Duplique des pièces dans ton jeu pour que progressivement le joueur récupère de la force de saut pour atteindre les plateformes :

Faire réapparaître les pièces

Dans le cas d’un jeu multi joueurs, donne la possibilité que les pièces réapparaissent au bout d’un certain temps dans le cas de plusieurs joueurs présents, modifie le script CoinService :

En plus d’utiliser des formes simples pour la création de tes plateformes, tu peux appliquer des opérations de modélisation en mixant les formes simples pour former des formes plus complexes, comme un tunnel dans une plateforme. Cette technique offre un intérêt visuel et de variation dans la façon dont les joueurs interagissent avec ton environnement.

Il existe quatre outils de modélisation des formes simples :

• Union – Joint deux ou plusieurs parties ensemble pour former une seule forme.
• Intersection – Intersecte les parties qui se chevauchent en une seule forme.
• Négation – Annule les parties, ce qui est utile pour faire des trous et des indentations.
• Séparer – Sépare l’union ou l’intersection en des formes individuelles.

Pour créer un tunnel creux, tu as besoin que des outils Union et Négative :

Pour réaliser un tunnel, tu as besoin des deux formes simples suivantes :

Puis traverse le cylindre avec la forme bloc, le bloc doit traverser de part en part le cylindre pour créer le tunnel :

Sélectionne le bloc puis demande l’outil Négativer, le boc devient transparent :

Sélectionne les deux formes le cylindre et le bloc, puis clic sur l’outil Union :

Ton tunnel est créé :

Tu peux rajouter cette forme dans ton parcours et la glisse dans l’arborescence Plateformes :

Puis renomme cette forme :

Crée des zones de danger qui vont réduire la santé des joueurs lorsqu’ils les touchent. Pour commencer, apprend à créer une grande partie invisible au niveau de l’eau, de sorte que tomber dans celle-ci entraine la disparition du joueur et le fasse recommencer au début du jeu.

Pour créer cette zone de danger :

1. Dans la fenêtre de l’Explorateur , ajoute un nouveau dossier dans le dossier Monde , puis renomme-le : Hazards .
2. Dans le dossier Hazards , insére une partie bloc et renomme-la Hazard :

Sur le + à droite de World demande à insérer un Model :

Puis renomme ce model en Hazards :

Puis dans l’onglet MODELE, demande un nouveau Elément Bloc :

Puis glisse ce nouvel objet sous Hazards :

Renomme le Hazard :

Déplace et met à l’échelle la zone de danger pour couvrir l’eau autour des plates-formes. Par exemple, avec ces données :

Puis modifie ces propriétés pour que la zone de danger soit invisible et que les joueurs puissent le traverser :

Règle la transparence sur 1. Cela rend le danger invisible, de sorte que l’eau réelle semble être le danger:

Désactive CanCollide . Cela indique au moteur ROBLOX que les autres parties peuvent traverser le danger sans interruption, ce qui signifie que les joueurs peuvent tomber à travers le danger.

Active Ancre . Cela indique au moteur ROBLOX de ne jamais modifier la position de la zone de danger.

Crée un script dans ServerScriptService , puis renommez-le en HazardService :

Remplace le code par défaut par le code suivant :

Joue et tombe dans l’eau autour des plateformes :