Catégorie : ROBLOX

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.

Prise en main de ROBLOX :

Menu

---

Explications plus techniques

---

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 pour déplacer un part

Objectif : Créer un système pour déplacer une part à droite, à gauche, en haut, vers le bas.

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 quatres boutons pour déplacer la part à droite et à gauche, haut et bas.

Comment indiquer une ressource dans un script :

local openButton = script.Parent.QuitButton

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

openButton.MouseButton1Click:Connect(function()

end)

Programmation pour ouvrir ou fermer la fenêtre de contrôle dans un LocalScript :

local controFrame = script.Parent.Parent:WaitForChild("ControlFrame")
local openButton = script.Parent
local closeButton = controFrame.QuitButton

-- Ouverture de la fenêtre de contrôle
openButton.MouseButton1Click:Connect(function()
	controFrame.Visible = not controFrame.Visible
	openButton.Visible = false
end)

-- Fermeture de la fenêtre de contrôle	
closeButton.MouseButton1Click:Connect(function()
	controFrame.Visible = not controFrame.Visible
	openButton.Visible = true
end)

downButton.MouseButton1Click:Connect(function()
	myPart.Position += Vector3.new(0,-2,0)
end)

controFrame.Visible = false
myPart.Anchored = true

Comment déplacer un objet Roblox :

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

Exemple de code pour déplacer le part en modifiant ton localScript :

local controFrame = script.Parent.Parent:WaitForChild("ControlFrame")
local openButton = script.Parent
local closeButton = controFrame.QuitButton

local downButton = controFrame.DownButton
local leftButton = controFrame.LeftButton
local rightButton = controFrame.RightButton
local upButton = controFrame.UpButton

local myPart = game.Workspace:WaitForChild("MyPart")

-- Ouverture de la fenêtre de contrôle
openButton.MouseButton1Click:Connect(function()
	controFrame.Visible = not controFrame.Visible
	openButton.Visible = false
end)

-- Fermeture de la fenêtre de contrôle	
closeButton.MouseButton1Click:Connect(function()
	controFrame.Visible = not controFrame.Visible
	openButton.Visible = true
end)

-- Déplacement du part
leftButton.MouseButton1Click:Connect(function()
	myPart.Position += Vector3.new(-10,0,0)
end)

rightButton.MouseButton1Click:Connect(function()
	myPart.Position += Vector3.new(10,0,0)
end)

upButton.MouseButton1Click:Connect(function()
	myPart.Position += Vector3.new(0,2,0)
end)

downButton.MouseButton1Click:Connect(function()
	myPart.Position += Vector3.new(0,-2,0)
end)

controFrame.Visible = false
myPart.Anchored = true

---

Partie 04 : Crée un Chat au joueur

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

Rajouter un ModuleScript 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 :

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

— récupération du player dans un localScript
local player = game:GetService(« Players »).LocalPlayer

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 le Model Platforms

:

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 mobilePlatformsScript:

Dans le script rajoute cette programmation :

-- Référence pour retrouver le dossier des plateformes
-- dans le workspace
local myWord = game.Workspace:WaitForChild("My World")
local platforms = myWord:WaitForChild("Platforms")
local platformChildren = platforms:GetChildren()

-- Au lancement du jeu récupérer la position initiale des plateformes
for _, platform in ipairs(platformChildren) do
	local movement = platform:GetAttribute("movement")
	if movement ~= nil then
		platform:SetAttribute("startPosition", platform.Position)
		platform.Anchored = true
	end
end

-- Système de mouvement des plateformes
local function movementDevice(deltaTime)
	for _, platform in ipairs(platformChildren) do
		local movement = platform:GetAttribute("movement")
		if movement ~= nil then
			
			local speed = platform:GetAttribute("speed") or 20
			local startPosition = platform:GetAttribute("startPosition")			
			local endPosition = startPosition + movement
			
			
			-- Calculer la nouvelle position
			if movement.X > 0 then
				platform.Position = platform.Position + 
					Vector3.new(speed * deltaTime, 0, 0)
			end
			if movement.Y > 0 then
				platform.Position = platform.Position + 
					Vector3.new(0, speed * deltaTime, 0)
			end
			if movement.Z > 0 then
				platform.Position = platform.Position + 
								Vector3.new(0, 0, speed * deltaTime)
			end

			-- Vérifier si la plateforme a atteint la fin ou le début
			-- Inversion du mouvement en fonction de speed ou -speed 
			if movement.X > 0 and
				((platform.Position.X >= endPosition.X) or 
				 (platform.Position.X <= startPosition.X)) then
				speed = -speed
			end
			if movement.Y > 0 and
				((platform.Position.Y >= endPosition.Y) or 
				 (platform.Position.Y <= startPosition.Y)) then
				speed = -speed
			end
			if movement.Z > 0 and
				((platform.Position.Z >= endPosition.Z) or 
				 (platform.Position.Z <= startPosition.Z)) then
				speed = -speed
			end
			
			platform:SetAttribute("speed", speed)

		end
	end
end

-- Heartbeat est un événement du RunService.
-- C'est un événement qui se produit à chaque image du jeu.
-- Il permet de faire bouger des objets en douceur en fonction du temps réel
local RunService = game:GetService("RunService")
RunService.Heartbeat:Connect(movementDevice)

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 Platforms puis renomme Elevator :

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

Un exemple de code avec une mort rapide :

local deadlyPart = script.Parent

deadlyPart.Touched:Connect(function(player)
	local character = player.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if humanoid then
		humanoid.Health = humanoid.Health - 5
	end
end)

Un exemple de code avec une mort lente :

local deadlyPart = script.Parent
local startTime = 0


deadlyPart.Touched:Connect(function(player)
	local character = player.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if humanoid then
		if startTime > 0 and (tick() - startTime) > 0.2 then
			startTime = 0
		end
		if startTime == 0 then
			print(humanoid.Health)
			humanoid.Health = humanoid.Health - 5
			startTime = tick()
		end
	end
end)

---

Partie 08 : Rend une plateforme invisible avec un clickDetector ou ProximityPrompt

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

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 myClickDetector.MouseClick:Connect(function() pour détecter le clic.

Comment coder un ClickDetector sur le part :

local myFirstPart = script.Parent
local clickDetector = myFirstPart.ClickDetector
local mySecondPart =myFirstPart.MySecondPart

clickDetector.MouseClick:Connect(function()
	mySecondPart.Transparency=0
end)

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

Comment coder un ProximityPrompt sur le part

local myFirstPart = script.Parent
local proximity = myFirstPart.ProximityPrompt
local mySecondPart =myFirstPart.MySecondPart

proximity.Triggered:Connect(function(player)
	mySecondPart.Transparency=0
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 deux niveaux de chemin : Disposez les parts de manière à ce que le joueur doive sauter de part en part puis cliquer pour passer au niveau suivante.
   • Indice : Utilisez la Transparency pour rendre les parts invisibles du chemin.

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 :

local workspace = game:GetService("Workspace")
local hazards = workspace.World.Hazards:GetChildren()

local function onHazardTouched(player, hazard)
	if not hazard:GetAttribute("Enabled") then
		return
	end
	local character = player.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if humanoid then
		humanoid.Health = 0
	end

end

for _, hazard in hazards do
	hazard:SetAttribute("Enabled", true)
	hazard.Touched:Connect(function(player)
		onHazardTouched(player, hazard)
	end)
end

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.

local workspace = game:GetService("Workspace")
local hazards = workspace.World.Hazards:GetChildren()

local function onHazardTouched(player, hazard)
	if not hazard:GetAttribute("Enabled") then
		return
	end
	local character = player.Parent
	local humanoid = character and character:FindFirstChild("Humanoid")
	if humanoid then
		humanoid.Health = 0
	end

end

for _, hazard in hazards do
	hazard:SetAttribute("Enabled", true)
	hazard.Touched:Connect(function(player)
		onHazardTouched(player, hazard)
	end)
end

local runService = game:GetService("RunService")
local interval = math.random(5, 10)

local function updateFire()
	for _, hazard in hazards do
		local fire = hazard:FindFirstChildOfClass("ParticuleEmitter")
		if fire then
			fire.Enabled = not fire.Enabled
			hazard.SetAttribut("Enabled", fire.Enabled)
		end
	end
end

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 : Des portes à ouvrir

Objectif : Créer un labyrinthe avec des portes à ouvrir

Ouvrir une porte avec un bouton poussoir :

Construis une porte avec un bouton poussoir pour l’ouverture :

Avec un ClickDetector sur le bouton :

Intercepter le click sur le ClikDetector dans le script :

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local clickDetector = door.PushButton.ClickDetector

clickDetector.MouseClick:Connect(function(player)
	print("Le joueur "..player.Name, 
			"a demandé l'ouverture de la porte")
end)

Lance le jeu et click sur le bouton poussoir, un message s’affiche dans la sortie :

Puis modifie ton script pour « ouvrir la porte » en rendant invisible la Part de la porte :

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local clickDetector = door.PushButton.ClickDetector

clickDetector.MouseClick:Connect(function(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	door.Door.Transparency = 1
end)

Mais tu peux constater que le joueur ne passe pas la porte, pour éviter ce problème tu peux éviter la collision entre la porte et le joueur :

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local parts= door:GetChildren()

function openDoor(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	door.Door.Transparency = 1
	door.Door.CanCollide = false
end

Deux possibilités pour refermer la porte :

• un autre click par le joueur

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local clickDetector = door.PushButton.ClickDetector

clickDetector.MouseClick:Connect(function(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	if door.Door.CanCollide then
		door.Door.Transparency = 1
	else
		door.Door.Transparency = 0
	end
	door.Door.CanCollide = not door.Door.CanCollide
end)

• fermeture automatique après un certain temps

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local clickDetector = door.PushButton.ClickDetector

clickDetector.MouseClick:Connect(function(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	door.Door.Transparency = 1
	door.Door.CanCollide = false
	
	task.wait(2)
	
	door.Door.Transparency = 0
	door.Door.CanCollide = true

end)

Ouverture de la porte avec deux boutons poussoirs :

Comment faire si deux boutons poussoirs de chaque coté de la porte :

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local parts= door:GetChildren()

function openDoor(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	if door.Door.CanCollide then
		door.Door.Transparency = 1
	else
		door.Door.Transparency = 0
	end
	door.Door.CanCollide = not door.Door.CanCollide

end

-- récupération de tous les clickDetectors
for _, part in ipairs(parts) do
	local clickDetector = 
              part:FindFirstChild("ClickDetector")
	if clickDetector then
		clickDetector.MouseClick:Connect(function(player)
			openDoor(player)
		end)
	end
end

Fermeture automatique de la porte

Comment refermer la porte automatiquement au bout d’un laps de temps :

-- Récupération de la porte
local door = script.Parent
-- Récupération du clickDetector
local parts= door:GetChildren()

function closeDoor()
	task.wait(2)
	if not door.Door.CanCollide then
		door.Door.Transparency = 0
		door.Door.CanCollide = true
	end
end	
	
function openDoor(player)
	print("Le joueur "..player.Name, 
		"a demandé l'ouverture de la porte")
	if door.Door.CanCollide then
		door.Door.Transparency = 1
		task.spawn(closeDoor)
	else
		door.Door.Transparency = 0
	end
	door.Door.CanCollide = not door.Door.CanCollide

end

-- récupération de tous les clickDetectors
for _, part in ipairs(parts) do
	local clickDetector = part:FindFirstChild("ClickDetector")
	if clickDetector then
		clickDetector.MouseClick:Connect(function(player)
			openDoor(player)
		end)
	end
end

Ouvrir une porte par une zone de détection :

Crée un part invisible autour de la porte qui aura la fonction d’une zone de détection de l’entrée ou la sortie du joueur :

Modifie les propriétés de la zone de détection

Supprime l’option de la possibilité de la collision :

Rend transparent la zone de collision :

Et évidement ancre la zone de détection :

Modifie le script pour détecter l’entrée et la sortie du joueur de la zone de détection :

-- Récupération de la porte
local door = script.Parent
local detectionZone = door.DetectionZone
-- Le joueur rentre dans la zone de détection
detectionZone.Touched:Connect(function()
	print("entrée")
end)
-- Le joueur sort de la zone de détection
detectionZone.TouchEnded:Connect(function()
	print("sortie")
end)

Ouvrir et fermer la porte avec la détection du joueur :

-- Récupération de la porte
local door = script.Parent
local detectionZone = door.DetectionZone

-- Le joueur rentre dans la zone de détection
detectionZone.Touched:Connect(function()
	print("entrée")
	if door.Door.CanCollide then
		door.Door.Transparency = 1
		door.Door.CanCollide = false
	end
end)

-- Le joueur sort de la zone de détection
detectionZone.TouchEnded:Connect(function()
	print("sortie")
	if not door.Door.CanCollide then
		door.Door.Transparency = 0
		door.Door.CanCollide = true
	end
end)

Rajoute une temporisation avant la fermeture de la porte pour éviter des ouvertures et des fermetures intempestives quand le joueur reste sur le bord de la zone de détection :

-- Récupération de la porte
local door = script.Parent
-- Récupération de la zone de détection
local detectionZone = door.DetectionZone
-- Temps d'attente avant fermeture de la porte
local TIMEOUTCLOSE = 2

-- Le joueur rentre dans la zone de détection
detectionZone.Touched:Connect(function()
	print("entrée")
	if door.Door.CanCollide then
		door.Door.Transparency = 1
		door.Door.CanCollide = false
	end
end)

-- Le joueur sort de la zone de détection
detectionZone.TouchEnded:Connect(function()
	print("sortie")
	if not door.Door.CanCollide then
		task.spawn(function()
			door.Door.CanCollide = true
			task.wait(TIMEOUTCLOSE)
			if door.Door.CanCollide then
				door.Door.Transparency = 0
			end
		end)
	end
end)

Rajouter un son d’ouverture

Ouvrir la boîte à outils pour trouver un son d’ouverture de porte :

Choisir Audio :

Saisir une recherche :

Choisir un son pour le mettre dans l’arborescence du workspace de la porte :

Puis modifie le script pour rajouter le son lors de l’ouverture de la porte :

-- Récupération de la porte
local door = script.Parent
-- Récupération de la zone de détection
local detectionZone = door.DetectionZone
-- Temps d'attente avant fermeture de la porte
local TIMEOUTCLOSE = 2
local soundDoor = door.door_open

-- Le joueur rentre dans la zone de détection
detectionZone.Touched:Connect(function()
	print("entrée")
	if door.Door.CanCollide then
		soundDoor:Play()
		door.Door.Transparency = 1
		door.Door.CanCollide = false
	end
end)

-- Le joueur sort de la zone de détection
detectionZone.TouchEnded:Connect(function()
	print("sortie")
	if not door.Door.CanCollide then
		task.spawn(function()
			door.Door.CanCollide = true
			task.wait(TIMEOUTCLOSE)
			if door.Door.CanCollide then
				door.Door.Transparency = 0
			end
		end)
	end
end)

Ouvrir une porte par une rotation :

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 :

-- Récupération du clickDetector
local clickDetector = script.Parent.Handle.ClickDetector
-- Récupération de la porte
local door = script.Parent.Door
-- Récupération de la distance d'activation du clickdetector
local distance = clickDetector.MaxActivationDistance

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

-- Fonction de détection de clic di clickdetector
clickDetector.MouseClick:Connect(function()
	doorRotation(door, 1, 90)
end)
end


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

-- Fonction de détection de clic
clickDetector.MouseClick:Connect(function()
	doorRotation(door, 1, 90)
	task.wait(5)
	doorRotation(door, -1, 90)
end)

Modifier le script pour un déplacement de 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 un bouton PLAY.
2. Créer un localScript de démarrage : Lancer le jeu par le bouton play.

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

Crée un localScript pour afficher le bouton PLAY puis lancer le jeu :

-- Caméra fixée sur le joueur
local camera = workspace.CurrentCamera
local playButton = script.Parent

camera.CameraType = Enum.CameraType.Fixed

-- Caméra floue autour du joueur
local BLUR = 8
local Lighting = game:GetService("Lighting")
blurEffect = Instance.new("BlurEffect")
blurEffect.Parent = Lighting
blurEffect.Size = BLUR

-- Joueur immobile
local player = game.Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
humanoid = character:FindFirstChild("Humanoid")
local walkSpeed = humanoid.WalkSpeed
humanoid.WalkSpeed = 0

local rotation = true

-- Play pour le lancement du jeu
playButton.MouseButton1Click:Connect(function()
	rotation = false
	humanoid.WalkSpeed = walkSpeed
	camera.CameraType = Enum.CameraType.Custom
	blurEffect.Size = 0
	playButton.Visible = false
end)

-- Effet pour la rotation du personnage
local humanidRootPart = character:FindFirstChild("HumanoidRootPart")
while rotation do
	humanidRootPart.CFrame = humanidRootPart.CFrame * CFrame.Angles(0, math.rad(1), 0)
	task.wait(0.01)
end

---

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)

Exemple d’un script pour augmenter le score si le joueur rentre en collision avec un part :

local myPart = script.Parent


myPart.Touched:Connect(function(hit)

	-- Vérifie si c'est un joueur qui a touché la part
	local joueur = game:GetService("Players"):GetPlayerFromCharacter(hit.Parent)
	if joueur then
		-- Trouve le score du joueur dans Leaderstats
		local leaderstats = joueur:FindFirstChild("leaderstats")
		if leaderstats then
			local score = leaderstats:FindFirstChild("Score")
			if score then
				-- Incrémente le score
				score.Value = score.Value + 1
			end
		end
	end

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

---

Partie 18 : Courir plus vite

Crée un bouton pour courir plus vite dans ton jeu Roblox !

Objectif : Dans ce tutoriel, tu vas apprendre à ajouter un bouton spécial dans ton jeu Roblox. Quand le joueur cliquera dessus, son personnage courra plus vite ! C’est une fonctionnalité simple mais super utile pour rendre ton jeu plus dynamique et amusant.

Ce que tu vas découvrir

• Tu vas découvrir comment modifier les propriétés d’un personnage notamment sa vitesse.
• Tu vas apprendre à créer une interface pour le joueur principalement un bouton à cliquer.
• Tu vas utiliser des scripts en Lua, le langage de programmation de Roblox, un script en local, un script sur le serveur et le système de dialogue entre le local et le serveur

Comment ça marche

Le rôle du LocalScript

• Imagine que tu es un joueur devant ton écran.
• Quand tu cliques sur un bouton (par exemple un bouton « Courir vite »), ton ordinateur doit comprendre que tu as fait cette action.
• C’est le travail du LocalScript (côté client, c’est-à-dire ton PC).
• Le LocalScript dit : « Hé serveur, le joueur a cliqué sur ce bouton ! »

Le LocalScript s’occupe d’écouter tes actions (clics, touches, GUI).

Le rôle du Script (serveur)

• Le serveur, c’est un peu comme le maître du jeu.
• Il reçoit les messages envoyés par les joueurs.
• C’est lui qui a le dernier mot : il décide si l’action est acceptée ou non (pour éviter les tricheurs par exemple).
• Le Script (serveur) dit : « J’ai bien reçu le clic du joueur. Maintenant je vais changer sa vitesse à 30 ! »

Le Script côté serveur s’occupe de changer le monde du jeu pour tout le monde.

Comment ils parlent entre eux ?

Ils utilisent un téléphone spécial appelé RemoteEvent.

• Le LocalScript appelle FireServer() → pour envoyer un message au serveur.
• Le Script serveur écoute avec OnServerEvent → pour réagir au message.

Crée un remoteEvent sous ReplicatedStorage :

Renomme ton RemoteEvent :

Maintenant crée un bouton avec un localscript :

local btn = script.Parent
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local remote = ReplicatedStorage:WaitForChild("RunMoreEvent")

btn.Text = "Plus vite"

btn.MouseButton1Click:Connect(function()
	remote:FireServer(30)
end)

Crée un script sur le serveur pour traiter la modification de la vitesse du joueur :

Renomme ton script :

Puis saisie le code suivant :

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local remote = ReplicatedStorage:WaitForChild("RunMoreEvent")

remote.OnServerEvent:Connect(function(player, value)
	local humanoid = player.character:WaitForChild("Humanoid")
	humanoid.WalkSpeed = value -- vitesse modifiée
end)

Tu peux améliorer ton script local pour revenir à une vitesse normale :

local btn = script.Parent
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local remote = ReplicatedStorage:WaitForChild("RunMoreEvent")

local runMore = false
btn.Text = "Plus vite"

btn.MouseButton1Click:Connect(function()

	if runMore then
		runMore = false
		btn.Text = "Plus vite"
		remote:FireServer(16)
	else
		runMore = true
		btn.Text = "Normal"
		remote:FireServer(30)
	end

end)

Un exemple de code pour connaître la vitesse de chaque joueur lorsque celui-ci se connecte :

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local remote = ReplicatedStorage:WaitForChild("RunMoreEvent")

remote.OnServerEvent:Connect(function(player, value)
	local humanoid = player.character:WaitForChild("Humanoid")
	humanoid.WalkSpeed = value -- vitesse modifiée
end)

-- Vérification de la vitesse de départ de chaque joueur lorsqu'il se connecte
local Players = game:GetService("Players")
Players.PlayerAdded:Connect(function(player)
	print(player.Name .. " vient de rejoindre la partie !")
	local character = player.Character or player.CharacterAdded:Wait()

	if character then
		local humanoid = character:WaitForChild("Humanoid")
		print(player.Name .. " est prêt avec un Humanoid !")
		if humanoid then
			print(player.Name .. " : " .. humanoid.WalkSpeed)
		end
	end
end)

---

Partie 19 : Contrôle de la vitesse du player avec les touches du clavier W et X

Crée un localScript sous StarterCharacterScripts

• Roblox utilise les positions physiques des touches, pas les caractères.
• Pour un clavier AZERTY, utilise le KeyCode correspondant à la position QWERTY de la touche.

• A = Enum.KeyCode.Q
• Q = Enum.KeyCode.A
• W = Enum.KeyCode.Z
• Z = Enum.KeyCode.W

local UserInputService = game:GetService("UserInputService")
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:FindFirstChildOfClass("Humanoid")

-- Fonction pour augmenter la hauteur du saut
local function onKeyPress(input, gameProcessed)

	if input.KeyCode == Enum.KeyCode.X and not gameProcessed then
		print("appuiX", humanoid.WalkSpeed)
		if humanoid then
			humanoid.WalkSpeed += 10
		end
	end
	print(input.KeyCode, Enum.KeyCode.W)
	if input.KeyCode == Enum.KeyCode.Z and not gameProcessed then
		print("appui Z", humanoid.WalkSpeed)
		if humanoid then
			humanoid.WalkSpeed -= 10
		end
	end
end

-- Connecte l'événement
UserInputService.InputBegan:Connect(onKeyPress)

---

Partie 20 : Ouvrir un coffre

Dessine un coffre en deux parties, une base et un couvercle à ouvrir :

Déplace le pivot du part du couvercle vers l’arrière :

Le couvercle du coffre pivotera sur ce pivot pour ouvrir le coffre.

Crée un ProximityPrompt sur le couvercle :

Tu peux décaler le ProximityPrompt sur la droite ou la gauche avec un Attachment.

Tu peux également attacher avec un Attachment une poignée sur le couvercle du coffre. Avec un Attachment la poignée suivra le mouvement en rotation du couvercle.

Script pour intercepter l’appui sur le proximityPrompt et pour ouvrir ou fermer le coffre :

local cover = script.Parent.Cover
local proxi = cover.Attachment.ProximityPrompt
local open = false

-- Fonction d'affichage du texte en 
-- fonction de l'état de la porte
local function displayActionText(open)
	return open and "Fermer" or "Ouvrir"
end

-- Fonction de rotation de la porte
local function boxOpening(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
-- Activation du prompt
proxi.Triggered:Connect(function()
	-- ouverture / fermeture du coffre
	proxi.Enabled = false
	boxOpening(cover, open and 1 or -1, 90)
	open = not open
	proxi.ActionText= displayActionText(open)
	proxi.Enabled = true
end)
	
prox.ActionText= displayActionText(open)



---

Partie 21 : Allumer une lumière

Créer une pièce sombre avec un plafonnier et un interrupteur cliquable.
Quand on clique dessus, la lumière s’allume ou s’éteint.

Préparer les objets dans Roblox Studio

1. Crée une pièce :
   • Insère un cube (Part) → redimensionne-le pour faire une petite pièce.
   • Ferme les murs, le sol et le plafond
   • Choisis des couleurs sombres.
2. Ajoute le plafonnier :
   • Ajoute un petit Part sous le plafond, au centre.
   • Nomme-le « LightPoint ».
3. Ajoute la lumière :
   • Sélectionne le LightPoint.
   • Dans le menu +, ajoute un PointLight.
   • Mets Enabled = false pour que la lumière soit éteinte au départ.
4. Ajoute un interrupteur :
   • Crée un petit cube sur un mur → nomme-le LightSwitch.
   • Ajoute-lui un ClickDetector (c’est ce qui permet de cliquer dessus).
5. Mets l’ensemble sous un Model LightingSystem

Puis ajouter le script Lua

1. Clique sur ton model LightingSystem.
2. Ajoute un Script (pas LocalScript).
3. Colle ce code :

-- Récupération du système électrique
local lightingSystem = script.Parent
-- Récupération du point lumineux
local lightPoint = lightingSystem.LightPoint
-- Récupération de l'interrupteur
local lightSwitch = lightingSystem.LightSwitch



lightSwitch.ClickDetector.MouseClick:Connect(function()
	-- Inverse l'état de la lumière
	lightPoint.PointLight.Enabled = 
		not lightPoint.PointLight.Enabled

	if lightPoint.PointLight.Enabled then
		-- Allume la lumière
		lightPoint.PointLight.Brightness = 10
		lightPoint.Color = Color3.new(255, 255, 127)
	else
		-- Éteint la lumière
		lightPoint.PointLight.Brightness = 0
		lightPoint.Color = Color3.new(0, 0, 0)
	end
end)

-- Initialisation : la lumière est éteinte par défaut
lightPoint.PointLight.Enabled = false
lightPoint.PointLight.Brightness = 0
lightPoint.Color = Color3.new(0, 0, 0)

Généralisation du code si plusieurs interrupteurs ou plusieurs points de lumières sur le même système :

-- Récupération du système électrique
local lightingSystem = script.Parent:GetChildren()

local function toggleLight()
	print("click pour allumer")
	
	for _, part in pairs(lightingSystem) do

		for _, children in pairs(part:GetChildren()) do

			if (children.ClassName == "PointLight") then
				-- Inverse l'état de la lumière
				part.PointLight.Enabled = 
					not part.PointLight.Enabled

				if part.PointLight.Enabled then
					-- Allume la lumière
					print("allume")
					part.PointLight.Brightness = 10
					part.Color = Color3.new(255, 255, 127)
				else
					print("eteint")
					-- Éteint la lumière
					part.PointLight.Brightness = 0
					part.Color = Color3.new(0, 0, 0)
				end
			end
		end
	end
end

for _, part in pairs(lightingSystem) do

	for _, children in pairs(part:GetChildren()) do

		if (children.ClassName == "PointLight") then
			-- Initialisation : la lumière est éteinte par défaut
			part.PointLight.Enabled = false
			part.PointLight.Brightness = 0
			part.Color = Color3.new(0, 0, 0)
		end
		
		if (children.ClassName == "ClickDetector") then
				part.ClickDetector.MouseClick:Connect(toggleLight)
		end
	end
end

---

Comprendre les variables et les fonctions

Lance projet Baseplate :

Crée un LocalScript sous StarterPlayer puis StarterPlayerScripts:

Lance le projet :

Choisis Sortie dans Fenêtre du menu :

Hello world ! est affiché dans la fenêtre Sortie :

Les variables

Arrête le code et saisie ce code dans ton localScript :

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

print("Le joueur est :", name)

Si tu relances ton jeu, tu obtiens dans Sortie le résultat suivant :

Tu viens d’utiliser une variable name pour stocker le nom du joueur pour l’afficher dans la sortie :

Pour déclarer une variable : local <nom de la variable>

Une variable est comme une boîte dans laquelle tu peux stocker une information (comme un nombre, un texte, etc.). Par exemple, la variable name, le nom du joueur et tu peux créer une variable score pour contenir le nombre de points d’un joueur :

local score = 0  -- Le joueur commence avec 0 point.

Affiche le score du joueur :

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

print("Le joueur est :", name)

local score = 0
print("Le joueur est :", name, "avec le score["..score.."]" )

Pourquoi utiliser une variable pour le score ?

a) Garder une trace du score

Sans variable, tu devrais te souvenir du score à chaque fois. Avec une variable, ton jeu mémorise le score pour toi !

b) Facile à modifier

Si tu veux modifier, ajouter des points ou enlever des points, tu peux facilement modifier la variable score :

score = 5
score = score + 1

Change la valeur de variable score :

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

print("Le joueur est :", name)

local score = 0
print("Le joueur est :", name, "avec le score["..score.."]" )

score = 5
print("Le joueur est :", name, "avec le score["..score.."]" )

Puis ajoute dans score :

score = score + 1
print("Le joueur est :", name, "avec le score["..score.."]" )

Ou :

score += 1
print("Le joueur est :", name, "avec le score["..score.."]" )

Tu dois obtenir ce résultat :

Tu dois avoir le code suivant dans ton localScript :

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

print("Le joueur est :", name)

local score = 0
print("Le joueur est :", name, "avec le score["..score.."]" )

score = 5
print("Le joueur est :", name, "avec le score["..score.."]" )

score = score + 1
print("Le joueur est :", name, "avec le score["..score.."]" )

score += 1
print("Le joueur est :", name, "avec le score["..score.."]" )

Les fonctions

Imaginons que tu es en train de créer un jeu sur Roblox et que tu veux afficher un message personnalisé pour chaque joueur pour l’informer de son score.

Voici pourquoi utiliser une function comme affichageDuScore est une super idée, même si elle semble simple !:

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

local function affichageDuScore(name, score)
	print("Le joueur est :", name, 
              "avec le score["..score.."]" )	
end

print("Le joueur est :", name)

local score = 0
affichageDuScore(name, score)

score = 5
affichageDuScore(name, score)

score = score + 1
affichageDuScore(name, score)

score += 1
affichageDuScore(name, score)

Qu’est-ce que la function affichageDuScore?

C’est une petite « machine » qui prend deux informations :

• Le nom du joueur.
• Son score.

local function affichageDuScore(name, score)
	print("Le joueur est :", name, 
			"avec le score["..score.."]" )	
end

Et elle affiche automatiquement le bon message. Par exemple :

11:39:01.641 Le joueur est : 123CODAGE avec le score[7] – Client – LocalScript:10

Pourquoi utiliser une fonction pour ça ?

Tout est au même endroit

Sans la fonction, tu devrais écrire le même code plusieurs fois dans ton jeu.

Avec la fonction, tu écris une seule fois la logique et tu l’utilises partout avec un simple :

affichageDuScore(name, score)

Et un autre exemple de forme de function :

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

local function affichageDuScore(name, score)
	print("Le joueur est :", name, 
			"avec le score["..score.."]" )	
end

local function scorePlus(score)
	return score + 1
end

print("Le joueur est :", name)

local score = 0
affichageDuScore(name, score)

score = 5
affichageDuScore(name, score)

score = scorePlus(score)
affichageDuScore(name, score)

score = scorePlus(score)
affichageDuScore(name, score)

Tu peux tester une variable, par exemple :

if score > 7 then
	print(name.." tu es le best")
else
	print(name.." tu peux mieux faire")
end

Qu’est-ce que la function isBest ?

Tu veux savoir si un joueur est un « champion » (par exemple, s’il a un score d’au moins 7). Voici pourquoi utiliser une function comme isBest est une super idée !

C’est une petite « boîte magique » qui répond à une question : « Est-ce que ce score fait de ce joueur un champion ? » Elle prend un score en entrée et retourne true (oui) ou false (non).

local function isBest(score)
	return score >= 7	
end

if isBest(score) then
	print(name.." tu es le best")
else
	print(name.." tu peux mieux faire")
end

Bien sûr ! Imaginons que tu crées un jeu sur Roblox où les joueurs ont un score. Tu veux savoir si un joueur est un « champion » (par exemple, s’il a un score d’au moins 7). Voici pourquoi utiliser une fonction comme estChampion est une super idée !

Qu’est-ce que la fonction isBest ?

C’est une petite « boîte magique » qui répond à une question : « Est-ce que ce score fait de ce joueur un champion ? » Elle prend un score en entrée et retourne true (oui) ou false (non).

Pourquoi utiliser une fonction pour ça ?

Éviter de répéter le même code

Sans la fonction, tu devrais écrire score >= 7 à chaque fois que tu veux vérifier si un joueur est un champion. Avec la fonction, tu écris isBest(score) et c’est tout !

Tu peux optimiser ton code :

local function isBest(score)
	return score >= 7	
end

print(name .. (isBest(score) and
	" tu es le best" or
	" tu peux mieux faire"))

Qu’est-ce qu’une constante ?

Une constante est une variable dont la valeur ne change jamais pendant que ton programme tourne. En Lua (le langage de Roblox), on utilise souvent une convention pour montrer que c’est une constante : on écrit son nom en majuscules.

Exemple :

local POINTS_PAR_VICTOIRE = 1

Même si ajouter 1 point semble simple, utiliser une constante comme POINTS_PAR_VICTOIRE a plusieurs avantages :

a) Facile à modifier plus tard

Si demain tu veux que le joueur gagne 2 points au lieu de 1, tu n’as qu’à changer une seule ligne :

local POINTS_PAR_VICTOIRE = 2  -- Au lieu de 1

ans constante, il faudrait chercher tous les endroits où tu as écrit + 1 et les modifier un par un. Avec une constante, c’est automatique !

b) Plus clair et compréhensible

Quand tu lis ce code :

score = score + POINTS_PAR_VICTOIRE

Tu comprends tout de suite que le joueur gagne des points pour une victoire. Si tu vois juste + 1, tu ne sais pas pourquoi on ajoute 1.

Le code complet

print("Hello world!")
local Players = game:GetService("Players")
local name = Players.LocalPlayer.Name

local INCREMENT_SCORE = 1
local BEST = 7

-- Affichage du score
local function affichageDuScore(name, score)
	print("Le joueur est :", name, 
			"avec le score["..score.."]" )	
end

-- Plus sur le score
local function scorePlus(score)
	return score + INCREMENT_SCORE
end

-- Si champion
local function isBest(score)
	return score >= BEST	
end

print("Le joueur est :", name)

local score = 0
affichageDuScore(name, score)

score = 5
affichageDuScore(name, score)

score = scorePlus(score)
affichageDuScore(name, score)

score = scorePlus(score)
affichageDuScore(name, score)

print(name .. (isBest(score) and
	" tu es le best" or
	" tu peux mieux faire"))

Faire courir le joueur

Voici une démarche étape par étape pour créer un menu, ajouter un bouton et lui attacher un LocalScript dans Roblox Studio. Suis ces instructions dans l’ordre pour que tout fonctionne !

Créer un menu (ScreenGui)

Un menu dans Roblox est souvent un ScreenGui (une interface qui s’affiche à l’écran).

Étapes :

1. Dans l’onglet Explorer (à droite), trouve StarterGui.
2. Clique droit sur StarterGui ou le petit + → Insérer un objet → ScreenGui.
   • Cela crée un ScreenGui (ton menu).

Maintenant, ajoute un bouton dans ton ScreenGui.

Étapes :

1. Dans l’Explorer, sélectionne ton ScreenGui (MenuPrincipal).
2. Clique droit sur ScreenGui ou le petit + → Insérer un objet → TextButton.
   • Un bouton apparaît dans ton menu.
3. Personnalise le bouton :
   • Dans l’onglet Propriétés (à droite), modifie Text : Écris "Vitesse plus" (le texte sur le bouton).

Ajouter un LocalScript au bouton

Un LocalScript permet de faire réagir le bouton quand un joueur clique dessus.

Étapes :

1. Dans l’Explorer, sélectionne ton bouton (TextButton).
2. Clique droit sur BoutonJouer → Insérer un objet → LocalScript.
   • Un LocalScript apparaît dans le bouton.

Écrire le code du LocalScript pour changer la vitesse de course du joueur :

local Players = game:GetService("Players")
local btn = script.Parent

-- change la vitesse du joueur
local speed = 40 -- vitesse du joueur

btn.MouseButton1Click:Connect(function()
	print("Le joueur a cliqué sur le bouton")
	local character = Players.LocalPlayer.Character or 
		Players.LocalPlayer.CharacterAdded:Wait()
	local humanoid = character:WaitForChild("Humanoid")

	humanoid.WalkSpeed = speed
end)

Explication du code :

• script.Parent : Fait référence au bouton (TextButton).
• MouseButton1Click:Connect(...) : Écoute le clic de la souris sur le bouton.
• Quand le bouton est cliqué, le code à l’intérieur de la fonction s’exécute pour changer la vitesse du joueur

---

Les listes

Une liste, c’est comme une boîte qui contient plusieurs objets, rangés les uns après les autres.

👉 En Lua, on appelle ça une table.
C’est un peu comme un carton à cases : chaque case contient quelque chose.

Crée un script sous le Workspace :

Pour écrire une liste {} :

local scores = {10, 20, 30, 12, 51}
print(scores)

Si tu lances le projet, tu constates ce résultat dans Sortie :

Tu peux également construire une liste de listes :

local scores = {{"Chloé",10}, 
				{"Noah",20}, 
				{"Alexandre",30}, 
				{"Kilyan",12}, 
				{"Louise",51}}
print(scores)

Tu peux supprimer un item d’une liste en précisant son rang en commençant par 1 :

local scores = {{"Chloé",10}, 
				{"Noah",20}, 
				{"Alexandre",30}, 
				{"Kilyan",12}, 
				{"Louise",51}}
table.remove(scores, 2)
print(scores)

Rajouter en fin de liste un nouveau item :

local scores = {{"Chloé",10}, 
				{"Noah",20}, 
				{"Alexandre",30}, 
				{"Kilyan",12}, 
				{"Louise",51}}
table.remove(scores, 2)
table.insert(scores, {"Esteban", 23})
print(scores)

Tu peux connaître le nombre items dans une liste :

local scores = {{"Chloé",10}, 
				{"Noah",20}, 
				{"Alexandre",30}, 
				{"Kilyan",12}, 
				{"Louise",51}}
table.remove(scores, 2)
table.insert(scores, {"Esteban", 23})
print(scores)
print(#scores)

Tu peux lire la liste dans une boucle :

local scores = {{"Chloé",10}, 
				{"Noah",20}, 
				{"Alexandre",30}, 
				{"Kilyan",12}, 
				{"Louise",51}}
table.remove(scores, 2)
table.insert(scores, {"Esteban", 23})
print(scores)
print(#scores)
for index, score in ipairs(scores) do
	print(index,"nom : "..score[1],"score : "..score[2])
end

Si tu n’as pas besoin de l’index de la table :

for _, score in ipairs(scores) do
	print("nom : "..score[1],"score : "..score[2])
end

Si tu veux connaître tous les items de ton workspace, tu peux demander à les mettre dans une liste et ainsi les manipuler :

	
local folders = workspace:GetChildren()

print(folders)

for _, folder in ipairs(folders) do
	print(folder.Name, folder.ClassName)
end

Et également un sous répertoire du workspace :

local folders = workspace:GetChildren()

print(folders)

for _, folder in ipairs(folders) do
	print(folder.Name, folder.ClassName)
	if folder.ClassName == "Part" then
		for _, subFolder in ipairs(folder:GetChildren()) do
			print("-",subFolder.Name, subFolder.ClassName)
		end
	end
end

Si tu veux généraliser pour lire tous le workspace :

local function explore(folder, indent)

	for _, obj in ipairs(folder:GetChildren()) do
		print(string.rep("-", indent), "Nom :", obj.Name, " | Type :", obj.ClassName)

		-- Si l'objet contient d'autres objets, on recommence dedans
		if #obj:GetChildren() > 0 then
			explore(obj, indent+1)
		end
	end
end

-- On commence par le Workspace
explore(workspace, 0)

Allumer la lumière

cc

---

Changer les propriétés d’un objet ROBLOX

Renomme le part en « MyPart »:

Lance ton jeu et visualise ton part :

Crée un script sur ton part :

local myPart = script.Parent

• Ici, on crée une variable qui s’appelle myPart.
• Cette variable pointe vers l’objet auquel le script est attaché (par exemple un part dans Roblox Studio).
• Comme ça, au lieu de réécrire script.Parent tout le temps, on peut juste écrire myPart.

Changer la couleur du bloc

local myPart = script.Parent

myPart.Color = BrickColor.Blue()

myPart.Color = BrickColor.Blue()

• On dit à Roblox : « change la couleur du bloc ».
• myPart.Color correspond à la propriété couleur du bloc.
• BrickColor.Blue() dit : prends la couleur bleue de Roblox.

Donc, cette ligne change la couleur du bloc en bleu.

Une autre façon de mettre une couleur :

myPart.Color = Color.new(0, 0, 255)

Qu’est-ce que RGB ?

• R = Rouge (Red)
• G = Vert (Green)
• B = Bleu (Blue)

local myPart = script.Parent

myPart.BrickColor = BrickColor.new(0, 1, 0)

for red = 0, 255 do
	myPart.Color = Color3.fromRGB(red, 0, 0)
	task.wait(0.01)
end

for green = 255, 0, -1 do
	myPart.Color = Color3.fromRGB(0, green, 0)
	task.wait(0.01)
end

for blue = 0, 255 do
	myPart.Color = Color3.fromRGB(0, 0, blue)
	task.wait(0.01)
end

Ce sont les 3 couleurs de base de la lumière (comme les lampes de ton écran).
En les mélangeant, on peut obtenir toutes les autres couleurs.

local myPart = script.Parent


while true do
	
	for red = 0, 255, 50 do
		for green = 0, 255, 50 do
			for blue = 0, 255, 50 do
				myPart.Color = Color3.fromRGB(red, green, blue)
				task.wait(0.01)
				print(red, green, blue)
			end	
		end	
	end

end

Fixer le bloc

Sous la pression du player le bloc bouge ou tombe :

local myPart = script.Parent

myPart.Anchored = true

myPart.Anchored = true

• Anchored est une propriété du bloc.
• En anglais, ça veut dire ancré ou fixé.
• Quand Anchored = true, le bloc ne peut plus bouger avec la gravité ou les collisions.
• Quand Anchored = false, le bloc tombe si rien ne le soutient, et il peut être poussé.

Rendre transparent le bloc

local myPart = script.Parent

myPart.Anchored = true
myPart.Transparency = 0.5

Transparency veut dire transparence (comme du verre).

C’est une valeur qui va de 0 à 1 :

• 0 = pas transparent du tout (opaque, on voit bien le bloc).
• 1 = complètement transparent (invisible).
• Entre les deux (par exemple 0.5), le bloc est semi-transparent (on le voit un peu mais on voit aussi à travers).

Traverser le bloc

local myPart = script.Parent

myPart.Anchored = true
myPart.Transparency = 0.5
myPart.CanCollide = false

En anglais, « Can Collide » = « peut entrer en collision ».

C’est une propriété booléenne (elle peut être soit true, soit false).

• true → le bloc est solide, on peut marcher dessus, il bloque le joueur.
• false → le bloc devient fantôme, on peut traverser comme s’il n’était pas là.

Déplacer le boc

local myPart = script.Parent

myPart.Anchored = true
myPart.Transparency = 0.5
myPart.CanCollide = false

for x = 1,200, 0.1 do
	myPart.CFrame = myPart.CFrame + Vector3.new(x, 0, 0)	
	task.wait(0.1)
end

CFrame = Coordinate Frame (en anglais).
C’est la position ET l’orientation d’un objet dans l’espace 3D.
Quand tu modifies CFrame, tu dis à Roblox :
« mets mon bloc à une nouvelle position dans le monde ».

Vector3 = un point ou un déplacement dans l’espace 3D.
Il a 3 nombres :

• x → gauche/droite (axe horizontal).
• y → haut/bas (axe vertical).
• z → avant/arrière (profondeur).

👉 Exemple :

• Vector3.new(5, 0, 0) = déplace de 5 cases à droite.
• Vector3.new(0, 5, 0) = monte de 5 cases.
• Vector3.new(0, 0, 5) = avance de 5 cases.

myPart.CFrame = myPart.CFrame + Vector3.new(x, 0, 0)

On dit :
« prends la position actuelle du bloc, et ajoute-lui un déplacement de x sur l’axe X (droite/gauche) ».

Tourner le bloc

Quand tu ajoutes un Vector3, tu modifies la position (où est le bloc).
Quand tu ajoutes une rotation, tu modifies l’orientation (comment il est tourné).

myPart.CFrame = CFrame.Angles(0, math.rad(90), 0)

Le bloc pivote d’un quart de tour (comme tourner une porte ouverte à angle droit).

CFrame.Angles crée une rotation.

Les trois valeurs x, y, z correspondent à des rotations en radians :

• x → rotation autour de l’axe X (il bascule en avant/arrière).
• y → rotation autour de l’axe Y (il tourne comme une toupie).
• z → rotation autour de l’axe Z (il penche sur le côté).

math.rad(90)

math.rad() convertit les radians en degré

radians=degrés×(180/π)​

Faire grossir un bloc et voir sa masse grandir

Un script simple qui montre comment la masse d’un bloc change quand on le fait grossir.

local myPart = script.Parent

myPart.Color = BrickColor.Blue()

-- On affiche la masse au début
print("Masse au départ :", myPart:GetMass())

-- On agrandit le bloc petit à petit
for i = 1, 5 do
	wait(1)  -- attend 2 secondes
	myPart.Size = myPart.Size + Vector3.new(2, 2, 2)  -- grossit de 2 en largeur, hauteur et profondeur

	print("Nouvelle taille :", myPart.Size)
	print("Nouvelle masse :", myPart:GetMass())
end

Dans Roblox Studio :

1. Clique sur ton bloc dans Explorer.
2. Fais + et ajoute un BillboardGui.
3. Dans ce BillboardGui, ajoute un TextLabel.

local myPart = script.Parent
local billboard = myPart:FindFirstChild("BillboardGui")

-- Positionnement de l'étiquette sur le coté droit de la part
billboard.StudsOffset = Vector3.new(4, 0, 0)

if billboard then
	-- TextLabel qui affiche la masse
	local label = billboard:FindFirstChild("TextLabel")
	-- Couleur de fond transparente pour laisser la part visible
	label.BackgroundTransparency = 1
	label.Text = ""
	if label then
		-- Fait grossir le bloc et met à jour la masse
		for i = 1, 5 do
			task.wait(1)
			myPart.Size = myPart.Size + Vector3.new(2, 2, 2)
			-- Fonction pour mettre à jour le texte avec la masse
			billboard.StudsOffset = billboard.StudsOffset + Vector3.new(2, 0, 0)
			label.Text = "Masse : " .. math.floor(myPart:GetMass())
		end
	else
		warn("TextLabel not found in BillboardGui")
	end
else
	warn("BillboardGui not found in MyPart")
end

---

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 !

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 :