Catégories
ROBLOX

Crée ton premier jeu OBBY

Créer un OBBY

Dans l’univers de Roblox, un « Obby » (abréviation de « Obstacle Course », ou parcours d’obstacles en français) est un type de jeu très populaire où les joueurs doivent traverser une série d’obstacles de plus en plus difficiles pour atteindre la fin du parcours. Voici ce qui caractérise un Obby et pourquoi ce genre est si apprécié :

1. Principe de base

  • Objectif : Le but est de terminer le parcours en évitant ou en surmontant tous les obstacles (sauts, plateformes mobiles, pièges, etc.).
  • Difficulté progressive : Les niveaux deviennent généralement plus difficiles au fur et à mesure que le joueur avance.

2. Types d’obstacles courants

  • Sauts de précision : Plateformes étroites ou éloignées les unes des autres.
  • Pièges : Lames, trous, obstacles en mouvement, etc.
  • Mécaniques uniques : Portails, téléporteurs, gravité inversée, etc.
  • Défis temporels : Certains Obby imposent une limite de temps pour chaque section.

3. Pourquoi les Obby sont-ils populaires ?

  • Accessibilité : Faciles à comprendre, mais difficiles à maîtriser, ce qui les rend adaptés à tous les niveaux de joueurs.
  • Créativité : Les créateurs de Roblox peuvent concevoir des parcours très variés, avec des thèmes et des mécaniques uniques.
  • Compétition : Les joueurs aiment se mesurer les uns aux autres en termes de temps ou de capacité à terminer le parcours.
  • Récompenses : Certains Obby offrent des badges, des objets virtuels ou de la monnaie en jeu pour les joueurs qui les terminent.

4. Exemples de mécaniques avancées

  • Checkpoints : Points de sauvegarde pour éviter de recommencer depuis le début après une chute.
  • Power-ups : Objets spéciaux qui aident le joueur (double saut, vitesse accrue, etc.).
  • Thèmes variés : Univers futuristes, médiévaux, horreur, etc.

5. Comment en créer un ?

  • Dans Roblox Studio, les créateurs utilisent des parts (blocs), des scripts (pour les pièges ou mécaniques avancées) et des outils de terrain pour construire leur Obby.
  • La communauté Roblox partage souvent des tutoriels et des modèles 3D pour aider les nouveaux créateurs.

En résumé, un Obby est un jeu de plateforme et d’adresse où le défi et la créativité sont au cœur de l’expérience. Si vous voulez essayer, il existe des milliers d’Obby gratuits sur Roblox, allant du très simple au extrêmement difficile !

Critères :

  1. Créer un monde : Votre obby doit vous ressembler.
  2. Créer des obstacles : Utiliser les parts de Roblox ou des objets graphiques extérieurs.
  3. Créer des pièges et des mécanismes : piège mortel, portail …
  4. Ne pas utiliser la tool-box : Évitez d’utiliser la tool-box pour les scripts et certains obstacles.

Partie 01 : Créer un Lobby

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

Dans un jeu Roblox, et notamment dans un Obby, le « lobby » (ou hall d’entrée en français) est une zone essentielle qui sert de point de départ et de rassemblement pour les joueurs avant qu’ils ne commencent le parcours ou le jeu proprement dit.

Exemple d’un lobby

  • Dans un Obby, le lobby peut ressembler à une petite île, une salle ou une plateforme avec un grand panneau « Start » ou « Commencer ». Les joueurs cliquent sur ce panneau (ou marchent dessus) pour être téléportés au début du parcours d’obstacles.

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 :

Suggestion pour la suite

Pour t’aider, n’oublie pas d’utiliser la fenêtre de sortie pour debugger tes scripts en affichant des traces ou le contenu de variables :

N’hésite pas à mettre des commentaires dans tes scripts :

Commentaire d’une ligne :

— commentaire sur une ligne

Commentaire de plusieurs instructions :

–[[
commentaire sur plusieurs lignes
commentaire sur plusieurs lignes
–]]


Partie 02 : Crée tes plateformes

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 :


Partie 03 : Crée un menu à ton joueur

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)


Partie 04 : Crée un Chat au joueur

Comment gérer un message d’indication au joueur par un Chat :

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 05 : Fais bouger les plateformes

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 06 : Crée un système de plateformes mobiles

Crée une plateforme par Modèle Elément Bloc :

Glisse ce nouvel objet sous le folder World puis Plateformes :

Dimensionne et place ta plateforme mobile dans l’espace de ton jeu :

Puis choisis de créer un nouvel attribut par le + dans les propriétés de la plateforme mobile :

Puis donne la valeur du déplacement soit sur l’axe X ou Y ou Z :

Crée un nouveau script dans ServerScriptService, puis renomme en PlatformService :

Dans le script rajoute cette programmation :

Crée une plateforme type ascenseur

Crée un nouveau bloc au dimension de ton ascenseur :

Puis glisse ce nouveau bloc dans l’explorateur sous Plateformes puis renomme le en Ascenseur :

Comme dans l’exemple tu peux le rendre transparent :

Puis créé deux nouveaux attributs movement et speed pour son déplacement vertical :


Partie 07 : Crée une plateforme mortelle

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 08 : Rend une plateforme invisible avec un clickDetector

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 09 : 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 10 : Crée un système de zones de danger

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 :

Rajoute des animations sur les zones de danger

Mettre le feu

Installe une zone où un incendie se déclenche aléatoirement, à ne pas traverser au péril de perdre une vie.

Dans la boîte à outil recherche une animation d’un feu : fire :

Sélectionne l’animation Realistic Fire With Smoke, un feu avec de la fumée. Puis glisse cette animation sous Hazards :

Positionne ton incendie à un endroit stratégique de ton jeu :

Modifie le script HazardService en ajoutant cette programmation qui va sur un intervalle de temps aléatoire allumer ou éteindre le feu en rendant ainsi la zone dangereuse ou pas.

Le joueur doit attendre la fin de l’incendie pour pouvoir passer.

Si tu le souhaites, tu peux installer plusieurs zones de feu dans ton jeu :

Une explosion

Rajoute un bloc sous Hazards et renomme le Explosion :

Puis utilise le + à droite de Explosion pour rajouter ParticleEmitter :

Que tu renommes Explosion :

Puis modifie les propriétés suivantes :

Teste le résultat et reviens sur les paramètres pour obtenir le résultat que tu souhaites :

Puis rends le socle transparent et canCollide à False :

Recommence pour une nouvelle zone de danger avec ce nouvel effet comme celui-ci :

Trouve les bons paramètres.


Partie 11 : Crée un 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 12 : Crée un menu au 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 13 : Crée une 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 14 : Crée un 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 15 : 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 16 : 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 17 : Crée un système de 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 !

Catégories
Non classé ROBLOX

ROBLOX suggestions :

Commentaire d’une ligne :

–print(« instruction en commentaire »)

Commentaire de plusieurs instructions :

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

Recherche d’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)

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)

Comment détecter une collision du joueur avec un objet Roblox :

maPart.Touched:Connect(function(otherPart)

local character = otherPart.Parent
local player = game:GetService(« Players »):GetPlayerFromCharacter(character)

if player then
local humanoid = character:FindFirstChildWhichIsA(« Humanoid »)

if humanoid then
print(« le joueur touche le part »)
end

end

end)

Comment détecter une fin de collision avec le joueur :

maPart.TouchEnded:Connect(function(otherPart)

local character = otherPart.Parent
local player = game:GetService(« Players »):GetPlayerFromCharacter(character)

if player then
local humanoid = character:FindFirstChildWhichIsA(« Humanoid »)

if humanoid then
print(« le joueur ne touche plus le part »)
end

end

end)

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

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)

Catégories
ROBLOX

Découverte ROBLOX

Connexion ou Inscription sur ROBLOX

Utilise cette icone dans la barre des tâches dans le bas de ton écran pour lancer ROBLOX STUDIO :

Si tu as déjà un compte ROBLOX tu peux saisir ton identifiant :

Si tu n’as pas de compte alors clic sur le lien Vous n’avez pas de compte ? S’inscrire :

Ouvrir un projet ROBLOX

Dans ROBLOX STUDIO choisis d’ouvrir le modèle Baseplate :

Manipulations simples avec la souris.

Tourner la roulette de la souris :

Appuie sur la molette de la souris et fais glisser la souris :

Maintenant clic sur le bouton droit et fais glisser la souris :

Clic sur l’objet sur la fenêtre le « SpawnLocation ». Cet objet matérialise le départ de ton joueur.

Avec les quatre outils suivants qui sont dans ta barre d’outils :

Tu peux :

  • Sélectionner
  • Déplacer
  • Modifier la taille
  • Effectuer une rotation

Essaye de déplacer l’objet :

Sur la partie droite de l’écran, tu retrouves les propriétés de l’objet dont sa position sur les trois axes x, y ,z :

Pour commencer à découvrir les concepts importants pour le développement sur Roblox: tu vas créer un jeu qui lance des projectiles sur des plates-formes flottantes.

Pour l’instant, tu as créé un projet avec le modèle Baseplate, qui comprend deux objets par défaut qui sont importants pour presque toutes les expériences sur la plateforme ROBLOX :

  • Emplacement d’apparition – Un objet SpawnLocation est l’endroit où les personnages des joueurs apparaissent dans l’espace 3D lorsqu’ils rejoignent une expérience, ainsi que l’endroit où ils réapparaissent lorsque leur santé atteint zéro.
  • Plaque de base – Une plaque de base est un sol avec une texture de grille 4×4.

Ce modèle est un excellent point de départ pour créer ta première expérience, car il fournit un monde neutre avec une technologie d’éclairage haute fidélité et un sol que tu peux utiliser pour positionner et orienter des objets 3D.

Tu peux le tester en utilisant l’outil Jouer :

Tu peux manipuler ton joueur avec les touches de clavier de déplacement, la barre d’espace pour sauter, ou lui donner une direction par un clic droit puis un glissé de la souris dans la direction souhaitée.

Manipule ton joueur puis arrête ton jeu :

Création d’un premier jeu

Pour te familiariser avec les objets 3D de ROBLOX, tu vas utiliser un pack d’éléments comprenant les objets 3D suivants qui créent le jeu de base pour ta première expérience :

Dans la boîtes à outil dans la partie gauche de l’écran, tape dans la zone de recherche : catapult :

Tu peux constater la mise en place de trois objets dans ton jeu :

Une catapulte à gauche et deux cibles en haut et à droite.

Sur la partie de droite dans Explorateur, tu retrouves la description des objets :

Pour jouer au jeu, il faut monter sur la catapulte, saisir les balles, viser les cibles puis tirer. Tu remarques que l’escalier pour atteindre la catapulte est à l’opposé du point de départ :

Tu vas utiliser l’outil déplacer pour mettre le point de départ devant l’escalier :

Lance ton jeu pour voir le résultat, tu peux constater que tu es devant l’escalier mais tu lui tournes le dos :

Arrête ton jeu et viens orienter ton joueur face à l’escalier par l’outil Rotation :

Utilise le cercle en vert pour orienter ton joueur face à l’escalier (180°). Dans les propriétés du SpawnLocation, tu retrouves la rotation de 180° :

Monte l’escalier :

Avec le clic gauche de la souris, tu peux diriger la catapulte :

Vas vers les boules, tu peux en appuyant sur la touche E placer les boules dans la catapulte. Mais pour l’instant ce mécanisme ne fonctionne pas :

Tu peux également déclencher par E le lancement mais pour l’instant le mécanisme ne fonctionne pas :

Arrête ton jeu pour le modifier pour permettre son fonctionnement :

Pour l’instant tu as interagi qu’avec des objets du service Workspace de ton modèle de données.

Il est important de garder à l’esprit l’emplacement d’exécution des scripts, sinon vos objets risquent de ne pas se comporter comme vous le souhaitez.

Pour garantir le fonctionnement de la catapulte, tu vas déplacer les objets des dossiers ReplicatedStorage et ServerScriptService dans leurs services de conteneur respectifs de ROBLOX.

ReplicatedStorage contient des objets disponibles à la fois pour le serveur et les différents joueurs connectés, notamment pour suivre le nombre de projectiles lancés par un joueur avant d’afficher l’interface utilisateur.

ServerScriptService contient des ressources liées aux scripts qui sont uniquement destinées à être utilisées par le serveur, pour la logique du jeu : qui positionne les projectiles sur la catapulte, lance des projectiles dans une direction particulière et réinitialise la catapulte à sa position de départ.

Sélectionne tous les objets sous introToStudioCatapult / RelicatedStorage :

Puis par un clic droit demander à couper :

Puis dans Explorateur sélectionne le répertoire ReplicatedStorage:

Puis colle les éléments coupés précédemment :

Tu obtiens ce résultat :

Réalise la même opération avec IntroToStudioCatapult ServerScriptService .

Couper :

Coller :

Lance ton jeu et maintenant tu dois pouvoir lancer les boulets :

Tu peux rapprocher les cibles !!!

Sauvegarde ton jeu dans ton répertoire :

Puis publie ton jeu :