Ce script crée un piège basé sur le temps : le joueur doit traverser une zone rapidement, sinon il meurt !
Le script utilise deux parts : part (visible, solide) et hidebox (une zone invisible qui sert à détecter le joueur, comme un capteur).
hidebox.CanCollide = false veut dire que cette zone est traversable : le joueur ne la voit pas et ne se cogne pas dessus, elle sert juste à « sentir » sa présence.
Quand le joueur entre dans la zone (Touched), le script note l’heure exacte grâce à tick() et la stocke dans le tableau lethalDuration, avec le personnage comme « étiquette ».
Quand le joueur sort de la zone (TouchEnded), le script calcule le temps passé dedans : tick() - lethalDuration[character].
Si ce temps est supérieur à DELTATIME (3 secondes), c’est que le joueur a été trop lent à traverser : sa vie est mise à 0 (humanoid.Health = 0), donc il meurt.
Si le joueur traverse en moins de 3 secondes, rien ne se passe : il a réussi l’épreuve !
En résumé : c’est un chronomètre invisible qui punit les joueurs trop lents à traverser une zone, un peu comme dans un jeu de plateforme où il faut courir avant qu’un mur ou un piège ne se referme.
QCM pour collégiens
1. À quoi sert la hidebox dans ce script ? A. À bloquer physiquement le joueur B. À détecter le passage du joueur sans être visible ni solide C. À afficher un message au joueur D. À téléporter le joueur
2. Que fait tick() dans ce script ? A. Il compte le nombre de joueurs B. Il donne l’heure exacte au moment où il est appelé C. Il déclenche une explosion D. Il redémarre le script
3. Quand se déclenche TouchEnded ? A. Quand le joueur entre dans la zone B. Quand le joueur sort de la zone C. Quand le joueur meurt D. Quand le jeu commence
4. Que se passe-t-il si le joueur reste plus de 3 secondes dans la hidebox ? A. Il gagne des points B. Il est téléporté au départ C. Sa vie tombe à 0 et il meurt D. Rien, il continue de jouer normalement
5. Pourquoi utilise-t-on character comme clé dans le tableau lethalDuration ? A. Pour donner un nom au joueur B. Pour retenir l’heure d’entrée de CHAQUE joueur individuellement C. Pour compter les vies du joueur D. Pour changer la couleur du personnage
6. Que représente la variable DELTATIME ? A. La vitesse du joueur B. Le temps maximum autorisé pour traverser la zone C. Le nombre de joueurs dans la partie D. La taille de la hidebox
local part = script.Parent
local hidebox = part:FindFirstChild("Hidebox")
local DELTATIME = 3
part.Anchored = true
part.CanCollide = true
part.CanTouch = true
hidebox.Anchored = true
hidebox.CanCollide = false
hidebox.CanTouch = true
local lethalDuration= {} -- [character] = true pendant le cooldown
hidebox.Touched:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
lethalDuration[character] = tick()
end)
hidebox.TouchEnded:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if tick() - lethalDuration[character] > DELTATIME then
humanoid.Health = 0
end
end)
Ce système affiche un chrono qui mesure le temps mis par un joueur pour aller d’un bloc de départ à un bloc d’arrivée.
Le script serveur est placé sur les blocs (départ/arrivée) : il détecte quand le joueur les touche (Touched) et décide quand le chrono doit démarrer ou s’arrêter.
Le LocalScript, lui, tourne uniquement sur l’ordinateur du joueur : il gère l’affichage du chrono à l’écran (le TextLabel).
Le serveur ne peut pas modifier directement l’écran d’un joueur : il doit envoyer un message au client via un RemoteEvent.
Le RemoteEvent fonctionne comme une messagerie entre le serveur et le client : quand le joueur touche le bloc de départ, le serveur « fire » (envoie) l’événement StartEvent.
Le LocalScript écoute cet événement avec OnClientEvent:Connect(...) et, dès qu’il le reçoit, enregistre l’heure de départ (tick()) et active running = true.
De la même façon, quand le joueur touche le bloc d’arrivée, le serveur envoie WinEvent, et le LocalScript reçoit ce signal pour arrêter le chrono (running = false).
Pendant que running est actif, la fonction RunService.Heartbeat recalcule et affiche le temps écoulé à chaque frame (60 fois par seconde environ).
La fonction formatTime transforme le nombre de secondes brut en un affichage lisible du type 01:23 (minutes:secondes).
En résumé : le serveur décide (quand démarrer/arrêter), les RemoteEvents transmettent l’info, et le LocalScript affiche le résultat à l’écran du joueur.
Petit rappel pour bien comprendre
Script serveur : tourne sur l’ordinateur qui héberge la partie. Il contrôle les règles du jeu, mais ne peut pas modifier ce qui s’affiche à l’écran d’un joueur précis.
LocalScript : tourne uniquement sur l’ordinateur du joueur. Il gère l’affichage (interface, sons, caméra…) mais ne peut pas être utilisé pour des règles importantes du jeu (sinon un joueur pourrait tricher).
RemoteEvent : le « pont » entre les deux. Le serveur envoie une info avec FireClient(), et le LocalScript la reçoit avec OnClientEvent:Connect().
QCM pour bien comprendre
1. Où s’exécute un LocalScript ? A. Sur le serveur du jeu B. Sur l’ordinateur du joueur uniquement C. Sur tous les ordinateurs en même temps D. Nulle part, c’est juste un fichier texte
2. Pourquoi ne peut-on pas modifier directement le TextLabel depuis le script serveur ? A. Parce que c’est interdit par Roblox B. Parce que le serveur n’a pas accès à l’affichage local de chaque joueur C. Parce que le TextLabel n’existe pas sur le serveur D. Parce que ça coûte trop cher en mémoire
3. À quoi sert un RemoteEvent ? A. À supprimer un joueur du jeu B. À transmettre une information entre le serveur et un client C. À changer la couleur d’un bloc automatiquement D. À sauvegarder les données du joueur
4. Que fait startEvent:FireClient(player) côté serveur ? A. Il supprime le joueur B. Il envoie un signal au client précis pour déclencher une action C. Il démarre le jeu pour tous les joueurs D. Il crée un nouveau RemoteEvent
5. Que fait RunService.Heartbeat dans ce script ? A. Il vérifie les battements de cœur du joueur B. Il exécute du code à chaque frame, ici pour actualiser l’affichage du chrono C. Il redémarre le serveur régulièrement D. Il compte le nombre de joueurs connectés
6. Que se passe-t-il si running vaut false ? A. Le chrono continue de s’incrémenter B. Le texte du chrono arrête de se mettre à jour C. Le joueur est téléporté au départ D. Le RemoteEvent est détruit
Crée un part pour déterminer le départ du chrono et un part pour déterminer le stop du chrono.
Puis deux RemoteEvent pour gérer le démarrage et l’arrêt du chrono :
Puis script sur le serveur pour gérer les collisions entre le player et les parts de départ et d’arrivée :
local replicatedStorage = game:GetService("ReplicatedStorage")
local remoteEvent = replicatedStorage:WaitForChild("Coursetimecheck")
local startEvent = remoteEvent.StartEvent
local winEvent = remoteEvent.WinEvent
local start = script.Parent.StartPart
local succes = script.Parent.SuccessPart
succes.SurfaceGui.Enabled = false
succes.ParticleEmitter.Enabled = false
succes.Anchored = true
succes.CanCollide = true
succes.CanTouch = true
start.Anchored = true
start.CanCollide = false
start.CanTouch = true
start.Transparency = 1
succes.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if succes.SurfaceGui.Enabled then return end
remoteEvent.WinEvent:FireClient(game.Players:GetPlayerFromCharacter(character))
succes.SurfaceGui.Enabled = true
succes.ParticleEmitter.Enabled = true
end)
start.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
local player = game.Players:GetPlayerFromCharacter(character)
if not player then return end -- sécurité si ce n'est pas un joueur (NPC par ex.)
print("StartEvent déclenché pour " .. player.Name)
startEvent:FireClient(player)
end)
Et également un localScript pour l’affichage du chrono pour le joueur :
-- Récupération des services
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")
-- Récupération du joueur actuel et de la PlayerGui
local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")
-- Récupération de l'UI du chrono
local chrono = playerGui:WaitForChild("ScreenGui"):WaitForChild("Frame"):WaitForChild("ChronoLabel")
-- Récupération des RemoteEvents start et stop du chrono
local remoteEventsFolder = ReplicatedStorage:WaitForChild("Coursetimecheck")
local startEvent = remoteEventsFolder:WaitForChild("StartEvent")
local stopEvent = remoteEventsFolder:WaitForChild("WinEvent")
-- Fonction pour formater le temps en minutes:secondes
local function formatTime(t)
local minutes = math.floor(t / 60)
local seconds = math.floor(t % 60)
return string.format("%02d:%02d", minutes, seconds)
end
-- Variables globales pour suivre le temps et l'état du chrono
local startTime = nil
chrono.Text = "00:00"
local running = false
-- Connexion des événements serveur au client
startEvent.OnClientEvent:Connect(function()
startTime = tick()
running = true
end)
stopEvent.OnClientEvent:Connect(function()
running = false
end)
-- Mise à jour continue de l'affichage du chrono
RunService.Heartbeat:Connect(function()
if not running or not startTime then return end
chrono.Text = formatTime(tick() - startTime)
end)
Ce script est attaché à un Part (bloc) et détecte quand un joueur le touche, via l’événement Touched.
Il vérifie que c’est bien un personnage avec un Humanoid, et bloque les déclenchements répétés grâce à un système de cooldown (table cooldowns).
Si le joueur n’a pas encore été rétréci/agrandi, le script sauvegarde sa taille actuelle dans un dossier Scale, puis applique la taille SCALEMAX (0.3) à sa hauteur, largeur, profondeur et tête.
Si le joueur a déjà été modifié (le dossier Scale existe), le script lui redonne sa taille d’origine et supprime le dossier.
Autrement dit : c’est un bloc « grandir/rétrécir » qui bascule (toggle) la taille du joueur à chaque contact, avec une seconde d’attente avant de pouvoir réutiliser le bloc.
QCM : Testez votre compréhension !
1. Que fait l’événement Touched dans ce script ? A. Il vérifie si le joueur a cliqué sur le bloc B. Il détecte quand quelque chose touche la Part C. Il compte le nombre de joueurs dans le jeu D. Il détruit le bloc
2. À quoi sert la variable COOLDOWN ? A. À changer la couleur du bloc B. À définir la taille maximale du joueur C. À empêcher de réutiliser le bloc trop vite D. À supprimer le personnage
3. Que se passe-t-il si le joueur touche le bloc une deuxième fois (après le cooldown) ? A. Rien, ça ne marche qu’une fois B. Le joueur reprend sa taille normale C. Le joueur devient minuscule D. Le jeu plante
4. À quoi sert le dossier (IntValue) nommé "Scale" ? A. À afficher un message au joueur B. À mémoriser la taille d’origine du joueur C. À compter le temps de cooldown D. À stocker le nom du joueur
5. Pourquoi utilise-t-on une table cooldowns avec le character comme clé ? A. Pour donner un nom à chaque joueur B. Pour savoir si CE joueur précis est en cooldown C. Pour compter les points de chaque joueur D. Pour changer la vitesse du joueur
local part = script.Parent
local SCALEMAX = 0.3
local COOLDOWN = 1 -- secondes avant de pouvoir re-déclencher
local cooldowns = {} -- [character] = true pendant le cooldown
part.Touched:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if cooldowns[character] then return end
cooldowns[character] = true
local existingFolder = humanoid:FindFirstChild("Scale")
if existingFolder then
humanoid.BodyHeightScale.Value = existingFolder.Value
humanoid.BodyWidthScale.Value = existingFolder.Value
humanoid.BodyDepthScale.Value = existingFolder.Value
humanoid.HeadScale.Value = existingFolder.Value
existingFolder:Destroy()
else
local folder = Instance.new("IntValue")
folder.Name = "Scale"
folder.Parent = humanoid
folder.Value = humanoid.BodyHeightScale.Value
humanoid.BodyHeightScale.Value = SCALEMAX
humanoid.BodyWidthScale.Value = SCALEMAX
humanoid.BodyDepthScale.Value = SCALEMAX
humanoid.HeadScale.Value = SCALEMAX
end
task.wait(COOLDOWN)
cooldowns[character] = nil
end)
Ce script surveille une part (un bloc) dans le jeu, et attend qu’un joueur la touche.
Quand un joueur la touche, le script vérifie qu’il s’agit bien d’un personnage (avec un Humanoid, la partie du jeu qui gère la santé, les déplacements, etc.).
Si c’est bien un joueur, sa vitesse de déplacement (WalkSpeed) passe à 50; il devient beaucoup plus rapide (par défaut, c’est 16).
QCM — vérifie ta compréhension
1. Que fait part.Touched:Connect(...) ? A) Il détruit la part B) Il détecte quand quelque chose touche la part C) Il déplace la part D) Il change la couleur de la part
2. Pourquoi le script vérifie if not humanoid then return end ? A) Pour vérifier que la part existe B) Pour arrêter le script si ce qui a touché n’est pas un personnage (par exemple un objet sans Humanoid) C) Pour ralentir le joueur D) Pour supprimer le Humanoid
3. Que représente Humanoid dans un personnage Roblox ? A) Le nom du joueur B) La couleur de la peau C) La partie qui gère la santé, les déplacements, etc. D) Un accessoire du personnage
4. Que se passe-t-il quand humanoid.WalkSpeed = 50 s’exécute ? A) Le joueur devient invisible B) Le joueur saute plus haut C) Le joueur se déplace plus vite D) Le joueur perd de la vie
5. Si un objet SANS Humanoid (comme une simple balle) touche la part, que se passe-t-il ? A) Le script plante avec une erreur B) Rien, le script s’arrête grâce au return C) La balle devient rapide D) Le jeu redémarre
local part = script.Parent
part.Touched:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
humanoid.WalkSpeed = 50
end)
Bascule courir plus vite / normalement
Quand un joueur touche la part, le script regarde s’il a déjà une vitesse « boostée » (mémorisée dans un petit objet nommé « Speed ») : si oui, il lui rend sa vitesse normale, sinon il sauvegarde sa vitesse actuelle et le rend très rapide (50).
Un système de « cooldown » (temps d’attente) empêche le joueur de retoucher la part plusieurs fois par seconde et de faire buguer le changement de vitesse.
Ainsi, la part fonctionne comme un interrupteur : un coup pour accélérer, un coup pour revenir à la normale, avec une petite pause obligatoire entre deux touches.
QCM — vérifie ta compréhension
1. À quoi sert la variable cooldowns ? A) À compter combien de joueurs ont touché la part B) À empêcher un joueur de redéclencher l’effet plusieurs fois trop vite C) À stocker la couleur de la part D) À sauvegarder le nom du joueur
2. Que fait l’objet IntValue nommé « Speed » ? A) Il affiche un message au joueur B) Il mémorise la vitesse de marche du joueur avant le boost, pour pouvoir la restaurer plus tard C) Il détruit le personnage D) Il change la couleur de la part
3. Que se passe-t-il si le joueur touche la part une seconde fois (sans cooldown actif) ? A) Sa vitesse redevient normale, car le dossier « Speed » existe déjà B) Rien ne se passe C) Sa vitesse augmente encore plus D) Le jeu plante
4. Pourquoi utilise-t-on task.wait(COOLDOWN) à la fin de la fonction ? A) Pour ralentir tous les joueurs du jeu B) Pour attendre 1 seconde avant de permettre au joueur de redéclencher l’effet C) Pour détruire la part après 1 seconde D) Pour attendre que le joueur meure
5. Si un joueur touche la part pendant que son cooldown est actif, que fait le script ? A) Il double sa vitesse B) Il arrête la fonction immédiatement avec return, sans rien changer C) Il redémarre le cooldown D) Il supprime le dossier « Speed »
local part = script.Parent
local SPEEDMAX = 50
local COOLDOWN = 1 -- secondes avant de pouvoir re-déclencher
local cooldowns = {} -- [character] = true pendant le cooldown
part.Touched:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if cooldowns[character] then return end
cooldowns[character] = true
local existingFolder = humanoid:FindFirstChild("Speed")
if existingFolder then
humanoid.WalkSpeed = existingFolder.Value
existingFolder:Destroy()
else
local folder = Instance.new("IntValue")
folder.Name = "Speed"
folder.Parent = humanoid
folder.Value = humanoid.WalkSpeed
humanoid.WalkSpeed = SPEEDMAX
end
task.wait(COOLDOWN)
cooldowns[character] = nil
end)
Essaye le même système pour faire sauter plus haut :
humanoid.JumpHeight = 20
local part = script.Parent
local SCALEMAX = 4
local COOLDOWN = 1 -- secondes avant de pouvoir re-déclencher
local cooldowns = {} -- [character] = true pendant le cooldown
part.Touched:Connect(function(plr)
local character = plr.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if cooldowns[character] then return end
cooldowns[character] = true
local existingFolder = humanoid:FindFirstChild("Scale")
if existingFolder then
humanoid.BodyHeightScale.Value = existingFolder.Value
humanoid.BodyWidthScale.Value = existingFolder.Value
humanoid.BodyDepthScale.Value = existingFolder.Value
humanoid.HeadScale.Value = existingFolder.Value
existingFolder:Destroy()
else
local folder = Instance.new("IntValue")
folder.Name = "Scale"
folder.Parent = humanoid
folder.Value = humanoid.BodyHeightScale.Value
humanoid.BodyHeightScale.Value = SCALEMAX
humanoid.BodyWidthScale.Value = SCALEMAX
humanoid.BodyDepthScale.Value = SCALEMAX
humanoid.HeadScale.Value = SCALEMAX
end
task.wait(COOLDOWN)
cooldowns[character] = nil
end)
Ce script Roblox rend transparents (invisibles à 75%) les joueurs ou leurs accessoires (comme un chapeau ou une épée) quand ils touchent une pièce (la part). Il vérifie si ce qui a touché la pièce est un personnage avec un Humanoid (un joueur). Ensuite, il parcourt toutes les parties du personnage (corps, accessoires) et les rend transparentes. Seules les pièces 3D (BasePart, MeshPart) ou les textures (Decal) sont modifiées.
QCM : Teste ta compréhension !
1. Que fait ce script quand un joueur touche la pièce ? A) Il supprime le joueur. B) Il rend le joueur et ses accessoires transparents. C) Il change la couleur du joueur en rouge. D) Il fait exploser la pièce.
2. Pourquoi vérifie-t-on if not humanoid then return end ? A) Pour éviter que le script ne s’applique aux objets qui ne sont pas des joueurs. B) Pour accélérer le jeu. C) Pour rendre la pièce invisible. D) Pour ajouter un accessoire au joueur.
3. Que signifie descendant.Transparency = 0.75 ? A) La pièce devient complètement invisible. B) La pièce devient à 75% transparente (presque invisible). C) La pièce clignote. D) La pièce devient plus grande.
4. Quel type d’objet n’est PAS modifié par ce script ? A) Un chapeau (Accessory). B) Une épée (MeshPart). C) Un mur (Part). D) Une texture (Decal) sur un accessoire.
-- Script pour rendre invisible les joueurs qui touchent la part
local part = script.Parent
part.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
for _, chose in ipairs(character:GetChildren()) do
if chose:IsA("Accessory") then
-- Rend transparent les BasePart/Decal de l'accessoire
for _, descendant in ipairs(chose:GetDescendants()) do
if descendant:IsA("BasePart") or descendant:IsA("Decal") then
descendant.Transparency = 0.75
end
end
elseif chose:IsA("MeshPart") then
-- Le MeshPart lui-même est la part à rendre transparente
chose.Transparency = 0.75
end
end
end)
Bascule invisible/visible
Ce script Roblox permet de rendre un joueur transparent à 50% quand il touche une pièce, puis de le rendre à nouveau visible s’il la touche une deuxième fois. Il utilise un délai de 1 seconde (COOLDOWN) pour éviter de déclencher l’effet trop vite. Un dossier caché (Transparency) est créé dans le personnage pour « mémoriser » s’il est déjà transparent. Seuls les joueurs (avec un Humanoid) sont concernés, et leurs accessoires ou parties du corps deviennent transparents.
QCM : Teste ta compréhension !
1. Que fait ce script quand un joueur touche la pièce pour la première fois ? A) Il le supprime. B) Il le rend transparent à 50%. C) Il le rend complètement invisible. D) Il le fait sauter.
2. Pourquoi utilise-t-on cooldowns[character] = true ? A) Pour empêcher le joueur de déclencher l’effet plusieurs fois en 1 seconde. B) Pour rendre le joueur invincible. C) Pour changer la couleur de la pièce. D) Pour ajouter un accessoire au joueur.
3. À quoi sert le dossier Transparency dans le Humanoid ? A) À stocker si le joueur est déjà transparent pour inverser l’effet au prochain contact. B) À rendre le joueur plus rapide. C) À supprimer le personnage. D) À afficher un message.
4. Que se passe-t-il si un joueur touche la pièce une deuxième fois ? A) Il devient à nouveau visible (transparence à 0%). B) Il devient complètement invisible. C) Il explose. D) Rien, le script ne fait plus rien.
-- Script pour rendre invisible les joueurs qui touchent la part
local part = script.Parent
local TRANSPARENCE_ACTIVE = 0.5
local TRANSPARENCE_INACTIVE = 0
local COOLDOWN = 1 -- secondes avant de pouvoir re-déclencherlocal cooldowns = {} -- [character] = true pendant le cooldownlocal function playerTransparency(character, transparency)
for _, chose in ipairs(character:GetChildren()) do
if chose:IsA("Accessory") then
-- Rend transparent les BasePart/Decal de l'accessoire
for _, descendant in ipairs(chose:GetDescendants()) do
if descendant:IsA("BasePart") or descendant:IsA("Decal") then
descendant.Transparency = transparency
end
end
elseif chose:IsA("MeshPart") then
-- Le MeshPart lui-même est la part à rendre transparente
chose.Transparency = transparency
end
end
end
part.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if cooldowns[character] then return end
cooldowns[character] = true
local existingFolder = humanoid:FindFirstChild("Transparency")
local transparency if existingFolder then
existingFolder:Destroy()
transparency = TRANSPARENCE_INACTIVE
else
local folder = Instance.new("Folder")
folder.Name = "Transparency"
folder.Parent = humanoid
transparency = TRANSPARENCE_ACTIVE
end
playerTransparency(character, transparency)
task.wait(COOLDOWN)
cooldowns[character] = nil
end)
Gestion d’un folder pour gérer plusieurs parts pour rendre invisible
-- Boucle sur toutes les parts du folder des parts pour rendre invisible
local folder = workspace:FindFirstChild("Zone Invisibilite", true)
for _, part in ipairs(folder:GetChildren()) do
if not part:IsA("BasePart") then return end
part.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
if cooldowns[character] then return end
cooldowns[character] = true
local existingFolder = humanoid:FindFirstChild("Transparency")
local transparency
if existingFolder then
existingFolder:Destroy()
transparency = TRANSPARENCE_INACTIVE
else
local folder = Instance.new("Folder")
folder.Name = "Transparency"
folder.Parent = humanoid
transparency = TRANSPARENCE_ACTIVE
end
playerTransparency(character, transparency)
task.wait(COOLDOWN)
cooldowns[character] = nil
end)
end
Traverser un mur quand le player est transparent
Quand un personnage touche la Part, le script vérifie s’il a un Humanoid possédant un attribut/valeur nommé "Transparency" , si oui, il rend la Part traversable (CanCollide = false).
Quand ce même personnage arrête de toucher la Part (TouchEnded), le script refait la vérification et remet la Part solide (CanCollide = true).
Résultat : c’est un bloc qui devient traversable uniquement pour les joueurs possédant la valeur « Transparency » (par exemple des joueurs rendus invisibles/fantômes ailleurs dans le jeu), et redevient solide dès qu’ils sont passés.
QCM : Teste ta compréhension !
1. Que vérifie le script avant de rendre la Part traversable ? A. Que le joueur a un pseudo spécial B. Que le personnage possède une valeur nommée « Transparency » C. Que le joueur est en l’air D. Que la Part est de couleur rouge
2. Que fait part.CanCollide = false ? A. Le bloc devient invisible B. Le bloc disparaît définitivement C. Le bloc laisse passer les objets/joueurs à travers D. Le bloc explose
3. Quand se déclenche l’événement TouchEnded ? A. Quand le joueur commence à toucher la Part B. Quand le joueur arrête de toucher la Part C. Quand le joueur meurt D. Quand le jeu se termine
4. Que se passe-t-il si un joueur SANS la valeur « Transparency » touche la Part ? A. Il traverse quand même le bloc B. Rien ne change, la Part reste solide pour lui C. Il devient invisible D. La Part se détruit
5. Pourquoi remet-on CanCollide = true dans TouchEnded ? A. Pour empêcher d’autres joueurs (sans la bonne valeur) de traverser après B. Pour changer la couleur du bloc C. Pour supprimer le joueur D. Pour recommencer le jeu
local part = script.Parent
part.Touched:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
local existingFolder = humanoid:FindFirstChild("Transparency")
if not existingFolder then return end
part.CanCollide= false
end)
part.TouchEnded:Connect(function(hit)
local character = hit.Parent
local humanoid = character and character:FindFirstChild("Humanoid")
if not humanoid then return end
local existingFolder = humanoid:FindFirstChild("Transparency")
if not existingFolder then return end
part.CanCollide= true
end)
local teleports = script.Parent
local teleportA = teleports.TeleportA
local teleportB = teleports.TeleportB
On récupère deux objets dans le jeu Roblox : la plateforme A (celle sur laquelle on va marcher) et la plateforme B (celle où on va arriver). Ces deux plateformes sont des enfants du script dans l’arbre du jeu.
L’événement Touched
teleportA.Touched:Connect(function(hit)
Touched est un événement Roblox : il se déclenche automatiquement dès que quelque chose touche la plateforme A. Le paramètre hit contient la pièce (la partie du corps) qui l’a touchée.
La vérification du joueur
local character = hit.Parent local humanoid = character and character:FindFirstChildOfClass("Humanoid") if not humanoid or humanoid.Health <= 0 then return end
On remonte d’un niveau pour trouver le personnage entier (hit.Parent), puis on cherche s’il contient un Humanoid (ce qui prouve que c’est bien un joueur, pas un mur ou une balle). Si rien de valide n’est trouvé, ou si le joueur est mort (Health <= 0), on arrête tout avec return.
La téléportation
local offset = Vector3.new(0, 2, 0) character:PivotTo(CFrame.new(teleportB.Position + offset))
Vector3.new(0, 2, 0) crée un décalage de 2 unités vers le haut pour que le joueur atterrisse au-dessus de la plateforme B et pas à l’intérieur. PivotTo est la fonction qui déplace instantanément tout le personnage à une nouvelle position — c’est ça la téléportation !
Le code complet de la téléportation
-- Configuration
local teleports = script.Parent
local teleportA = teleports.TeleportA
local teleportB = teleports.TeleportB
teleportA.Touched:Connect(function(hit)
-- Récupération du joueur
local character = hit.Parent
local humanoid = character and character:FindFirstChildOfClass("Humanoid")
if not humanoid or humanoid.Health <= 0 then return end
-- Décalage légert vers le haut pour poser le joueur sur la plateforme
local offset = Vector3.new(0, 2, 0)
character:PivotTo(CFrame.new(teleportB.Position + offset))
end)
Comment les véhicules autonomes naviguent-ils avec précision dans les réseaux routiers urbains complexes et les rues très fréquentées ? Comment les robots logistiques trouvent-ils efficacement les itinéraires optimaux dans les entrepôts labyrinthiques ? Ces problèmes, en apparence complexes, peuvent être explorés et résolus grâce à notre voiture UNIHIKER K10 !
Dans le cadre de ce projet, tu vas concevoir un robot de navigation routière. Ce robot sera capable d’identifier avec précision les intersections en T et les carrefours, et permettra également au véhicule de suivre des itinéraires prédéfinis et d’effectuer des manœuvres de virage aux intersections complexes. Il s’agit non seulement d’un projet de programmation stimulant, mais aussi d’une avancée significative vers les technologies de transport intelligent de demain.
Objectif de la tâche
Utilisez les algorithmes intégrés de l’UNIHIKER K10 pour détecter les intersections en T et les carrefours, permettant ainsi à la voiture d’identifier avec précision les intersections et d’exécuter des virages spécifiques en fonction de chemins prédéfinis au sein d’un réseau routier complexe.
Points clés
Maîtriser l’utilisation des algorithmes intégrés pour reconnaître les intersections complexes telles que les carrefours et les intersections en T.
Apprendre les méthodes de détection des intersections et de contrôle des virages.
Comprendre le concept de « réseau routier » et le rôle de la planification des itinéraires dans les futurs systèmes de transport.
Liste des matériaux
Configuration matérielle requise :
Exercice pratique
Maintenant que tu maîtrises les commandes de base du véhicule, tu vas aborder des scénarios plus complexes. Les deux tâches suivantes te guideront dans la mise en pratique de la détection des intersections et de la planification de la navigation, te permettant ainsi d’exploiter pleinement les capacités de perception et de prise de décision du véhicule.
Tâche 1 : Détection d’intersections complexes
En mode requête, le véhicule détecte en continu l’état actuel de l’intersection et fournit un retour d’information en temps réel sur les résultats de la reconnaissance. Les informations relatives à l’intersection identifiée s’affichent sur l’écran du UNIHIKER K10.
Tâche 2 : Chemin de navigation spécifié
En se basant sur un itinéraire prédéfini, planifie à l’avance le trajet de navigation du véhicule et programme le pour qu’il suive strictement cet itinéraire pendant son fonctionnement.
Tâche 1 : Détection d’intersections complexes
1. Connexion matérielle
Connecte le Maqueen à ton ordinateur à l’aide d’un câble USB 3.0 vers Type-C.
Remarque : L’extrémité de type C doit être connectée au UNIHIKER K10.
2. Préparation du logiciel
Ouvre Open Mind+ et suit les étapes de préparation du logiciel comme indiqué dans le schéma ci-dessous.
3. Programmation
(1) Configuration initiale
Pour utiliser la fonction de suivi de ligne intégrée du Maqueen Plus V3, exécute les opérations suivantes lorsque le message « UNIHIKER K10 On Start » s’affiche :
→ Utilise la commande « System initialization module » pour vous assurer que tous les modules fonctionnent correctement ;
→ Utilise la commande « set up a patrol route speed » pour régler la voiture à la vitesse de suivi de ligne la plus basse ;
→ Utilise la commande « patrolling on » pour activer la fonction de suivi de ligne, permettant à la voiture de circuler le long de la ligne noire.
(2) Détection d’intersections complexes
Dans la commande « forever », utilise l’instruction conditionnelle « If…Then » pour déterminer le type d’intersection actuellement détectée par la voiture.
Remarque : En mode requête, la voiture affiche différentes valeurs numériques lorsqu’elle reconnaît différents types d’intersections lors du suivi de ligne :
: Carrefour (intersection à 4 voies)
: Jonction en T
: Virage à gauche en ligne droite
: Virage à droite en ligne droite
Lorsque la commande « intersection detecting » renvoie la valeur 1, utilisez les commandes « cache text » et « Afficher le contenu mis en cache » pour afficher le texte « Carrefour détecté » sur l’écran UNIHIKER K10.
De même, lorsque la commande « intersection detecting » renvoie la valeur 2, indiquant qu’une intersection en T a été détectée, affichez le texte « Intersection en T détectée » sur l’écran UNIHIKER K10.
Lorsqu’une intersection avec virage à gauche suivi d’une voie continue ou virage à droite suivi d’une voie continue est détectée, la même méthode de vérification conditionnelle et d’affichage du texte est utilisée. Le programme complet est le suivant :
4. Exécution du programme
Avant de lancer le programme, assure-toi que le UNIHIKER K10 est correctement connecté à ton ordinateur via un câble USB. Après vérification, clique sur le bouton « Télécharger » du logiciel. Placezle véhicule sur la carte de suivi de ligne et allumez-le pour lancer le suivi. Lors de la détection d’intersections complexes, l’écran du UNIHIKER K10 affichera le type d’intersection correspondant.
Tâche 2 : Chemin de navigation spécifié
1. Programmation
(1) Planification du trajet Avant d’écrire le programme, planifie un itinéraire sur la carte comportant quatre types d’intersections. La voiture parcourra le trajet du point de départ à l’arrivée en passant par : deux intersections avec virage à gauche et possibilité de continuer tout droit, une intersection avec virage à droite et possibilité de continuer tout droit, deux carrefours et un carrefour en T. Chaque intersection est clairement indiquée par le sens de circulation correspondant, comme illustré ci-dessous :
(2) Configuration initiale
→ Utilise la commande « System initialization module » pour vous assurer que tous les modules fonctionnent correctement ;
→ Utilise la commande « set up patrol route speed » pour régler la voiture à la vitesse minimale de suivi de ligne ;
→ Utilise la commande « patrolling on » pour activer la fonction de suivi de ligne, permettant à la voiture de circuler le long de la ligne noire.
(3) Chemin de navigation spécifié
1) Jonctions en T (intersections 1, 5 et 6)
Sur le parcours illustré, le véhicule rencontre trois intersections en T, nécessitant à chaque fois une manœuvre de virage différente. Pour la première intersection en T, utilise la commande « setup up Trord » dans la section « UNIHIKER K10 au démarrage » afin d’effectuer un virage à gauche.
Lors de la deuxième intersection en T, les commandes de contrôle direct ne peuvent pas être utilisées pour les virages. Dans la commande « forever », implémente une logique conditionnelle à l’aide de l’instruction « if…then » pour évaluer la commande « intersection detecting ».
Crée une nouvelle variable « flag_T » pour comptabiliser le nombre de passages aux intersections en T. Lorsque la commande « intersection detecting » renvoie la valeur 1 (condition vraie), incrémentez cette variable à l’aide de la commande « Changer flag_T de 1 ».
Lorsque la variable flag_T vaut 1, cela indique que le véhicule rencontre une deuxième intersection en T. Utilise la commande « set up Trord à droite » pour effectuer un virage à droite.
Lorsque la variable flag_T atteint 3, marquant la troisième rencontre d’une jonction en T, utilisez la commande « set up Trordstop» pour interrompre le fonctionnement de suivi de ligne de la voiture.
2) Jugement au carrefour (intersections 2 et 3)
De même, lors de la première rencontre à un carrefour, utilisez la commande « set up intersection à gauche » dans la section « UNIHIKER K10 au démarrage » pour effectuer un virage à gauche.
Au deuxième carrefour, dans le programme « Forever », évaluez la commande « intersection detecting ». Si cette commande renvoie la valeur 1, utilisez la commande « Définir la trajectoire droite au carrefour » pour maintenir une trajectoire rectiligne.
3) Intersection avec virage à gauche et voie droite (Intersection 5)
Ce type d’intersection n’apparaît qu’une seule fois. Dans la section « UNIHIKER K10 Au démarrage », utilisez la commande « set up left or straight » pour maintenir une trajectoire rectiligne à travers cette intersection.
Le programme complet est le suivant :
2. Exécution du programme
Avant de lancer le programme, assure toi que le UNIHIKER K10 est correctement connecté à ton ordinateur via un câble USB. Après vérification, clique sur le bouton « Télécharger » du logiciel. Place le Maqueen sur la carte de suivi de ligne et allume-le pour lancer le suivi de ligne selon le parcours prédéfini.
3. Pratique pratique
Coin des connaissances
1. Qu’est-ce qu’un « réseau routier » ?
Un réseau routier désigne un système interconnecté de routes au sein d’une zone spécifique, formant un réseau de voies. Dans notre vie quotidienne, que ce soit dans les rues des villes, sur les campus, dans les usines ou les entrepôts, on peut considérer tous ces lieux comme des réseaux composés de routes et d’intersections : ce que l’on appelle un « réseau routier ».
1. Définition et composition des réseaux routiers
Un réseau routier est un système interconnecté de routes à différents niveaux, formant une structure de transport en forme de toile. Selon les régions, les réseaux routiers peuvent comprendre différents types de routes, comme les autoroutes, les routes urbaines et les routes rurales.
2. Classification des réseaux routiers
Réseaux routiers : Principalement composés de routes à différents niveaux, reliant les villes, les villages et les principaux nœuds de transport, constituant la composante principale du transport régional.
Réseaux routiers urbains : Réseaux formés par diverses routes au sein des zones urbaines, constituant l’infrastructure fondamentale des transports urbains.
3. Fonctions et rôles des réseaux routiers
Les réseaux routiers constituent l’ossature des transports urbains, offrant des voies de circulation à divers types de véhicules. Ils garantissent des déplacements sûrs, efficaces, économiques et confortables. La conception et l’optimisation des réseaux routiers sont essentielles pour réduire les embouteillages et améliorer l’efficacité des transports.
2. Quel rôle joue la planification des trajectoires dans les transports du futur ?
Imagine une ville du futur où les voitures circulent de manière autonome grâce à des systèmes intelligents, sans intervention humaine. Dans ce système, la planification d’itinéraire fait office de « cerveau » pour le véhicule, l’aidant à déterminer les trajets optimaux au sein de réseaux routiers complexes.
Les fonctions de la planification de trajectoire peuvent être résumées comme suit :
1. Gain de temps et réduction du trafic
Les véhicules autonomes sélectionnent les itinéraires les plus rapides en fonction des conditions de circulation en temps réel, évitant ainsi les embouteillages pour atteindre leur destination plus rapidement.
2. Amélioration de la sécurité et prévention des accidents
Il détecte de manière proactive les obstacles et les dangers, et ajuste automatiquement les itinéraires pour éviter les collisions.
3. Optimisation du trafic à l’échelle du système
Lorsque plusieurs véhicules planifient intelligemment leurs itinéraires, la circulation urbaine est plus fluide et le temps d’attente réduit.
4. Livraison autonome fiable
Les robots de livraison et les véhicules logistiques autonomes s’appuient sur la planification d’itinéraires pour naviguer avec précision dans les villes et les entrepôts, permettant ainsi une livraison de colis efficace avec une intervention humaine minimale.
En substance, la planification d’itinéraires fonctionne comme une carte de navigation invisible, permettant aux futurs véhicules et robots de « voir » intelligemment les routes et de garantir ainsi des arrivées sûres et rapides. Les systèmes de transport intelligents de demain reposeront fondamentalement sur ce « cerveau intelligent ».
Releve le défi
Imagine notre voiture dans un labyrinthe complexe : pourrait-elle utiliser son « intelligence » pour trouver la sortie ? N’est-ce pas à la fois fascinant et stimulant ? Voyons maintenant comment concevoir un tel robot capable de résoudre des labyrinthes, de reconnaître automatiquement les chemins, d’éviter les obstacles et, finalement, d’atteindre sa destination !
Dans le futur des transports intelligents et de la logistique automatisée, la technologie de conduite autonome transforme progressivement nos vies. Des voitures autonomes aux robots d’entrepôt intelligents, la navigation par suivi de ligne est l’une des technologies clés de ces innovations. Dans ce projet, nous explorerons deux méthodes de suivi de ligne différentes pour apprendre à votre voiture UNIHIKER K10 à suivre une ligne noire de manière autonome. Il s’agit non seulement d’un défi de programmation stimulant, mais aussi d’un point de départ pour explorer les futures technologies de transport intelligent. Grâce à ce projet, tu apprendras à un robot de percevoir son environnement et de prendre des décisions, jetant ainsi les bases d’innovations futures.
Objectif de la tâche
Cette tâche vise à mettre en œuvre deux méthodes de suivi de ligne distinctes pour permettre à la voiture de naviguer le long des lignes noires sur une carte en couleur. La première méthode consiste à lire les valeurs numériques de capteurs de suivi de ligne montés sur le châssis, tandis que la seconde utilise l’algorithme de suivi de ligne intégré du UNIHIKER K10.
Points clés
Comprendre le principe de fonctionnement et la méthode de détection des capteurs de suivi de ligne
Maîtriser les techniques de lecture des données provenant des capteurs de suivi de ligne
Apprendre à utiliser l’algorithme de suivi de ligne intégré de Maqueen Plus V3
Comparer les avantages et les inconvénients des algorithmes de suivi de ligne personnalisés et des algorithmes intégrés.
Liste des matériaux
Configuration matérielle requise :
Exercice pratique
Dans ce projet, tu exploreras la fonctionnalité de suivi de ligne à travers trois tâches progressives. Premièrement, tu apprendras à lire les valeurs numériques des capteurs de suivi de ligne. Ensuite, tu mettras en œuvre deux méthodes distinctes de suivi de ligne :
une programmation personnalisée et des algorithmes intégrés
pour contrôler le mouvement de la voiture sur la piste.
Tâche 1 : Lire les valeurs numériques des capteurs de suivi de ligne
Lire les valeurs numériques des capteurs de suivi de ligne à 5 canaux et affiche les en temps réel sur l’écran du K10.
Tâche 2 : Suivi de ligne de base
Développe un programme de contrôle basé sur les signaux numériques provenant des capteurs de suivi de ligne afin d’obtenir une fonctionnalité de suivi de ligne fondamentale.
Tâche 3 : Suivi de ligne à l’aide d’un algorithme intégré
Utilise l’algorithme de suivi de ligne intégré fourni par l’UNIHIKER K10 pour permettre une navigation autonome, rationalisant ainsi le processus de développement.
Tâche 1 : Lecture des valeurs numériques des capteurs de suivi de ligne
1. Connexion matérielle
Connecte le Maqueen à ton ordinateur à l’aide d’un câble USB 3.0 vers Type-C.
Remarque : L’extrémité de type C doit être connectée au UNIHIKER K10.
2. Préparation du logiciel
Lance Mind+ et terminez la configuration du logiciel comme illustré dans le schéma suivant.
3. Programmation
(1) Lecture des valeurs du capteur de suivi de ligne
Utilise la commande « lire l’état du capteur de ligne L1 » pour obtenir le signal numérique actuel du capteur (0 ou 1).
Affiche les valeurs acquises par le capteur de suivi de ligne sur l’écran UNIHIKER K10 à l’aide de la commande « cache text ». Active l’option « auto-clear » pour n’afficher que les dernières mesures.
Utilise la commande « join » pour combiner la valeur d’état de chaque capteur en un texte lisible (par exemple, L1 : [Lire l’état du capteur de ligne L1]).
Enfin, utilise la commande « show cached content » pour actualiser le contenu textuel à l’écran et activer l’affichage. Voici le programme complet :
4. Exécution du programme
Avant d’exécuter le programme, il est nécessaire de vérifier que l’UNIHIKER K10 est correctement connecté à l’ordinateur via un câble USB. Une fois la connexion vérifiée, clique sur le bouton « Télécharger » du logiciel. À la fin de l’exécution du programme, si les capteurs de suivi de ligne détectent des lignes noires, les voyants s’allument (valeur numérique = 1), tandis que lorsqu’aucune ligne noire n’est détectée, les voyants restent éteints (valeur numérique = 0).
Tâche 2 : Suivi de ligne personnalisé
1. Programmation
Cette tâche s’appuie sur le programme de la tâche 1. Pour obtenir une fonctionnalité de suivi de ligne basique, nous utiliserons uniquement les trois capteurs avant : L1, M et R1. Ces capteurs détermineront la position de la voiture par rapport à la ligne noire et effectueront les ajustements nécessaires.
Remarque : Bien que les trois capteurs de suivi de ligne puissent générer sept combinaisons différentes, cette analyse se concentrera sur trois cas principaux. Les autres scénarios peuvent être étudiés indépendamment.
En ligne droite : lorsque le capteur M détecte la ligne noire (valeur = 1), cela indique que la voiture est centrée sur la ligne. Utilisez la commande « Régler la rotation de tous les moteurs à la vitesse d’avancement de 100 » pour faire avancer simultanément les deux moteurs.
Virage à droite : Lorsque R1 détecte la ligne noire (1) et M la ligne blanche (0), cela indique que la voiture dévie vers la gauche et doit tourner à droite. Utilisez les commandes « Régler la vitesse de rotation du moteur gauche vers l’avant à 100 » et « Régler la vitesse de rotation du moteur droit vers l’arrière à 50 » pour faire tourner la voiture à droite.
Virage à gauche : Lorsque L1 détecte la ligne noire (1) et M la ligne blanche (0), cela indique que la voiture dévie vers la droite et doit tourner à gauche. Utilisez les commandes « Régler la vitesse de rotation arrière du moteur gauche à 50 » et « Régler la vitesse de rotation avant du moteur droit à 100 » pour faire tourner la voiture à gauche. Le programme complet est le suivant :
2. Exécution du programme
Avant de lancer le programme, vérifie que le UNIHIKER K10 est correctement connecté à votre ordinateur via un câble USB. Une fois la connexion établie, clique sur le bouton « Télécharger» du logiciel. Après l’exécution du programme, place le véhicule à son point de départ sur la carte ; il suivra alors la ligne noire.
Tâche 3 : Suivi de ligne à l’aide d’un algorithme intégré
1. Programmation
Dans cette tâche, nous utiliserons la fonction de suivi de ligne intégrée du robot UNIHIKER K10 (basé sur le DFRobot Maqueen Plus V2) pour obtenir un suivi de ligne autonome. Cette approche est relativement simple, car la majeure partie de la logique de suivi de ligne est déjà intégrée au matériel et au micrologiciel ; il nous suffit d’appeler les commandes appropriées.
Au début du programme, utilise la commande « System initialization mùodule » pour initialiser le système et t’assurer que tous les modules fonctionnent correctement.
Lors du suivi de ligne, utilise la commande « set up a patrol route speed » pour configurer la vitesse de suivi. Ce paramètre influe directement sur la vitesse de déplacement du véhicule en service.
Remarque : Le paramètre de vitesse accepte des valeurs comprises entre 1 et 5, ajustables selon les besoins. Plus la valeur est élevée, plus le mouvement est rapide ; plus elle est faible, plus le mouvement est lent.
Enfin, exécute la commande « patrolling on » pour activer la fonction de suivi de ligne intégrée. Voici l’implémentation complète du programme :
2. Exécution du programme
Avant d’exécuter le programme, vérifie que le UNIHIKER K10 est correctement connecté à votre ordinateur via un câble USB. Une fois la connexion établie, clique sur le bouton « Téléchargement » dans l’interface du logiciel. Après l’initialisation du programme, positionnez le véhicule au point de départ indiqué sur le circuit. Le système suivra alors automatiquement la trajectoire noire prédéfinie.
Coin des connaissances
1. Comprendre le principe de fonctionnement des capteurs de suivi de ligne
Chaque module de capteur de suivi de ligne contient deux sondes infrarouges : une pour l’émission infrarouge et une autre pour la réception infrarouge.
Les capteurs de suivi de ligne fonctionnent grâce aux propriétés de réflexion de la lumière. Sur une surface blanche, les lignes noires réfléchissent davantage de lumière que le fond blanc. Lorsqu’un capteur détecte une ligne noire au sol, il renvoie la valeur 1. En revanche, lorsqu’il détecte un fond blanc, il renvoie la valeur 0.
2. Comprendre les méthodes d’étalonnage des capteurs de suivi de ligne
Les capteurs de suivi de ligne du véhicule Maqueen Plus V3 sont calibrés en usine et généralement prêts à l’emploi. Toutefois, en cas de détection anormale pendant le fonctionnement (par exemple, sortie 1 avec voyants allumés dans les zones blanches), un recalibrage peut être effectué à l’aide du bouton de calibration intégré.
Procédure d’étalonnage :
Préparation : Place tous les capteurs de suivi de ligne avant du véhicule entièrement sur une surface noire, en veillant à une couverture complète.
Étalonnage : Maintiens enfoncé le bouton d’étalonnage de suivi de ligne jusqu’à ce que les voyants bleus des capteurs clignotent trois fois, indiquant que l’étalonnage est terminé.
Vérification de l’étalonnage :
Lorsqu’ils sont placés sur des surfaces noires, les voyants correspondants doivent s’allumer.
Lorsqu’ils sont placés sur des surfaces blanches, les voyants correspondants doivent s’éteindre.
Ce processus d’étalonnage corrige efficacement les erreurs de reconnaissance causées par les variations d’éclairage ambiant ou l’usure des composants, garantissant ainsi des performances de suivi de ligne précises et stables.
3. Comprendre les scénarios d’application des capteurs de suivi de ligne
Les capteurs de suivi de ligne sont des composants intelligents capables de détecter les variations de couleur ou de réflectivité du sol, principalement utilisés pour permettre aux robots de « reconnaître les chemins et de suivre les itinéraires désignés ». Ces capteurs servent non seulement de composants essentiels à la navigation autonome des véhicules intelligents, mais trouvent également de nombreuses applications dans divers scénarios du monde réel.
Dans la pratique, les capteurs de suivi de ligne trouvent de nombreuses applications. Par exemple, dans les entrepôts logistiques, les véhicules à guidage automatique (AGV) utilisent ces capteurs pour transporter et stocker efficacement les marchandises le long de voies prédéfinies, améliorant ainsi considérablement l’efficacité logistique. Dans les systèmes de transport intelligents, les véhicules autonomes utilisent des capteurs de suivi de ligne pour détecter le marquage au sol, garantissant ainsi le maintien de la trajectoire et renforçant la fiabilité des systèmes d’aide à la conduite. Les robots de service, tels que les robots de nettoyage et les robots de livraison hospitalière, s’appuient également sur ces capteurs pour la navigation intérieure autonome, permettant une prestation de services efficace.
De plus, dans le domaine de l’éducation et de la recherche, les capteurs de suivi de ligne constituent des outils essentiels pour les expériences pédagogiques et les compétitions de robotique, permettant aux étudiants et aux chercheurs d’étudier les principes de fonctionnement des capteurs et les algorithmes de contrôle. Dans les systèmes de surveillance de sécurité, ces capteurs peuvent détecter les limites de zones spécifiques afin d’empêcher tout accès non autorisé, que ce soit par des personnes ou des objets, garantissant ainsi la sécurité. Dans les applications d’agriculture intelligente, les capteurs de suivi de ligne assistent les robots agricoles dans la réalisation des opérations d’irrigation, de fertilisation et de récolte le long de parcours prédéfinis, améliorant considérablement l’efficacité de la production agricole.
Grâce à ces applications, les capteurs de suivi de ligne améliorent non seulement l’efficacité opérationnelle, mais aussi la fiabilité et la sécurité du système, apportant un soutien crucial au développement des futures technologies intelligentes.
Relevez le défi
Dans ce projet, tu as maîtrisé les fonctionnalités de base de suivi de ligne de la voiture. Cependant, dans la réalité, les itinéraires sont rarement statiques. Imagine ce scénario : la voiture peut rencontrer des carrefours, des intersections en T, voire des intersections complexes avec plusieurs voies convergentes.
Voici le défi : lorsque la voiture arrive à ces intersections, comment doit-elle déterminer la bonne direction ? Et comment pouvons-nous la programmer pour qu’elle prenne la bonne décision ?
Met ta casquette de réflexion et essaye de concevoir une méthode permettant à ta voiture intelligente de « prendre des décisions » de manière autonome lorsqu’elle se trouve face à ces « choix cruciaux » !
Créer un script pour afficher un tableau de score au joueur sousServerScriptService :
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 :
Si le score ne s’affiche pas vérifie :
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)
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)
Un système de score avec un ModuleScript
1. Créer un ModuleScript pour gérer les scores
-- ModuleScript dans ServerScriptService : "ScoreManager"
local ScoreManager = {}
-- Initialise le Leaderstats pour un joueur
function ScoreManager.initPlayer(player)
local leaderstats = Instance.new("Folder", player)
leaderstats.Name = "leaderstats"
local points = Instance.new("IntValue", leaderstats)
points.Name = "Score"
points.Value = 0
end
-- Met à jour le score d'un joueur
function ScoreManager.addPoints(player, points)
local leaderstats = player:FindFirstChild("leaderstats")
if leaderstats then
local score = leaderstats:FindFirstChild("Score")
if score then
score.Value = score.Value + points
end
end
end
return ScoreManager
Appel dans scriptServeur pour rajouter des points :
-- Script dans ServerScriptService
local ScoreManager = require(game:GetService("ServerScriptService"):WaitForChild("ScoreManager"))
-- Initialiser le Leaderstats pour chaque joueur
game.Players.PlayerAdded:Connect(function(player)
ScoreManager.initPlayer(player)
end)
local part = workspace.Part -- La Part qui déclenche l'événement
-- Exemple : Ajouter 10 points à un joueur
part.Touched:Connect(function(otherPart)
-- Vérifie que otherPart fait partie d'un personnage
local humanoid = otherPart.Parent:FindFirstChild("Humanoid")
if humanoid then
-- Récupère le joueur associé au personnage
local player = game.Players:GetPlayerFromCharacter(otherPart.Parent)
if player then
ScoreManager.addPoints(player, 10)
part:Destroy() -- Supprime la Part après utilisation
end
end
end)
As-tu imaginé ce que donnerait la voiture robot UNIHIKER K10 si elle devenait un robot intelligent de surveillance environnementale ? Elle pourrait non seulement afficher des données environnementales en temps réel, comme la température, l’humidité et la luminosité, mais aussi les représenter graphiquement pour nous aider à observer les tendances des changements environnementaux. Alors, partons de zéro et explorons étape par étape comment donner vie à cette idée aussi pratique que ludique !
Objectif de la tâche
Affiche les données d’humidité en temps réel sur l’écran UNIHIKER K10, enregistre-les et trace un graphique linéaire pour visualiser leur évolution. Utilisez la commande vocale pour consulter les valeurs d’humidité maximales et minimales.
Points de connaissance
Apprendre à collecter et à stocker des données environnementales.
Dessin du graphique principal et représentation visuelle.
Comprendre la logique de reconnaissance vocale et d’interaction avec les données.
Explorer les tendances en matière de surveillance environnementale intelligente.
Liste du matériel
Exercice pratique
Ce projet vise à collecter les données d’humidité mesurées par le capteur et à les représenter sous forme de graphique linéaire. La comparaison de ces données permettra d’identifier les valeurs d’humidité maximales et minimales. Enfin, des commandes vocales permettront de récupérer ces valeurs, qui seront affichées à l’écran une fois la commande vocale correctement reconnue. Pour atteindre cet objectif, le projet est divisé en deux tâches.
Tâche 1 : Tracer un graphique linéaire des données d’humidité
Stocke les données d’humidité surveillées en temps réel et représente-les sous forme de graphique linéaire afin de visualiser l’évolution des données.
Tâche 2 : Obtenir des données d’humidité par commande vocale
Ajoute une fonctionnalité de reconnaissance vocale pour permettre de répondre aux questions sur les données d’humidité. Utilise les commandes vocales pour obtenir les valeurs d’humidité maximale et minimale, et affichez ces valeurs à l’écran une fois les commandes vocales correctement reconnues.
Tâche 1 : Tracer un graphique linéaire des données d’humidité
1. Connexion matérielle
Utilise un câble de données USB 3.0 vers Type-C pour connecter la voiture robot assemblée à l’ordinateur.
Remarque : L’extrémité de type C doit être connectée au UNIHIKER K10.
2. Préparation du logiciel
Ouvre Mind+ et termine la configuration du logiciel comme indiqué dans les illustrations suivantes.
3. Programmation
Tracé d’un graphique linéaire, en utilisant des données d’humidité comme exemple.
(1) Représentation du système de coordonnées cartésiennes
Pour tracer un graphique linéaire sur l’écran UNIHIKER K10, il faut d’abord créer un système de coordonnées cartésiennes. La première étape consiste à utiliser la commande « set line width » pour définir l’épaisseur des lignes du système de coordonnées à 1. Si vous jugez les lignes trop fines, vous pouvez également la définir à 3, 4, etc.
Trace l’axe vertical (Y) à l’aide de la commande « cache draw line from, X1 Y1 to X2 Y2, color » afin de le créer à l’écran. Les coordonnées de départ de l’axe Y sont (10, 80) et les coordonnées d’arrivée sont (10, 280). Définis la couleur de la ligne sur noir pour que l’axe soit bien visible.
Trace l’axe horizontal (X) de la même manière. Définis son point de départ à (10, 280) et son point d’arrivée à (230, 280). Utilise ensuite la commande « show cached content » pour mettre à jour et afficher les axes X et Y sur l’écran UNIHIKER K10.
(2) Points de tracé
Après avoir défini le système de coordonnées cartésiennes, tu peux commencer à tracer les points. Avant cela, assure toi de déterminer les coordonnées X et Y de chaque point. Crée d’abord une nouvelle variable nommée « hum_x1 » pour stocker la coordonnée X du point, et initialise sa valeur à 10 .
L’ordonnée du point représente les données d’humidité, mais la valeur d’humidité ne peut pas être utilisée directement comme coordonnée Y. En effet, la plage de données d’humidité dépasse largement celle de l’écran, et l’échelle des valeurs est inverse à l’axe Y de l’écran. Pour résoudre ce problème, utilisez l’opérateur « map » afin d’associer la valeur d’humidité à une coordonnée Y correspondante sur l’écran UNIHIKER K10.
Crée une nouvelle variable nommée « hum_y1 » pour stocker les données d’humidité cartographiées. Initialise la valeur de « hum_y1 » avec la valeur d’humidité retournée par le capteur.
Ensuite, utilise la commande « cache draw point at XY color » pour tracer le point. Son abscisse est la variable « hum_x1 » et son ordonnée, la variable « hum_y1 ». Enfin, utilise la commande « show cached content » pour mettre à jour et afficher le point tracé sur l’écran UNIHIKER K10.
Après avoir placé le premier point, la coordonnée X correspondante doit être décalée de 10 unités vers la droite. Utilisez la commande « change hum_x1 by » pour incrémenter la valeur de hum_x1 de 10.
(2) Tracer des lignes
Après avoir tracé les points de données, l’étape suivante consiste à les utiliser pour créer un graphique linéaire. Utilise la commande « cache draw line from X1 Y1 to X2 Y2 color » pour relier les points en séquence et former une polyligne.
Pour déterminer les coordonnées de début et de fin de la ligne, créez deux nouvelles variables : « hum_x2 » et « hum_y2 ». Les coordonnées de début de la ligne (X1, Y1) correspondent aux coordonnées du premier point de données, soit (hum_x1, hum_y1). Les coordonnées de fin de la ligne (X2, Y2) correspondent aux coordonnées du point de données suivant, soit (hum_x2, hum_y2).
Au début du programme, sous « unihiker k10 au démarrage », initialise la valeur de « hum_x2 » à la valeur de « hum_x1 » et celle de « hum_y2 » à la valeur de « hum_y1 ».
Après avoir confirmé les points de départ et d’arrivée de la ligne, utilise la commande « cache draw line from X1 Y1 to X2 Y2 color » pour la tracer. Ensuite, utilise la commande « show cached content » pour afficher la ligne sur l’écran UNIHIKER K10.
Lorsque le point suivant est mis à jour, les coordonnées d’extrémité de la ligne doivent également être mises à jour. Pour ce faire, mettez à jour les valeurs de « hum_x2 » et « hum_y2 ».
Attribuez la valeur de « hum_x1 » à « hum_x2 », afin que « hum_x2 » stocke la coordonnée X du point précédent.
Attribuez la valeur de « hum_y1 » à « hum_y2 », afin que « hum_y2 » stocke la coordonnée Y du point précédent.
L’objectif de cette étape est de définir le point de départ de la nouvelle ligne afin qu’elle se connecte au point précédent.
4. Exécution du programme
Avant d’exécuter le programme, aassure toi que l’UNIHIKER K10 est correctement connecté à l’ordinateur via un câble USB. Une fois la connexion établie, clique sur le bouton « Transférer » du logiciel. Après l’exécution réussie du programme, un système de coordonnées cartésiennes s’affichera sur l’écran de l’UNIHIKER K10, et les données d’humidité mesurées en temps réel seront représentées graphiquement.
5. Essayez
Lors du tracé du graphique linéaire, tu peux rencontrer deux problèmes :
Les points de données s’actualisent trop rapidement, ce qui provoque des changements rapides sur le graphique linéaire et le rend difficile à observer.
Lorsque le nombre de points de données dépasse la plage de l’axe X de l’écran, le graphique continue de s’afficher, ce qui peut entraîner un affichage surchargé. Pour résoudre ce problème, vous pouvez prendre les mesures suivantes :
Ralentis la fréquence d’acquisition des données : ajoute un délai approprié entre les acquisitions afin de réduire la vitesse de génération des nouveaux points de données. Par exemple, tu peux insérer un court temps d’attente après la lecture de la valeur d’humidité et le tracé d’un nouveau point.
Limite la zone de dessin : pour garantir que le graphique linéaire soit dessiné uniquement à l’intérieur du système de coordonnées, tu dois soit limiter le nombre de points de données, soit restreindre la valeur de la coordonnée X.
Tâche 2 : Obtenir des données d’humidité par commande vocale
1. Programmation
Cette tâche s’appuie sur le programme « Essayez-le » de la tâche 1 en ajoutant le réveil vocal, la reconnaissance des commandes vocales et la capacité de reconnaître et de signaler les données d’humidité par interaction vocale.
(1) Initialisation de la fonction de reconnaissance vocale
Sous « unihiker k10 au démarrage », utilisez la commande « set speech recognition wake time ms language » pour initialiser le mode de reconnaissance vocale en continu, définir le délai de réveil à 6 secondes et choisir l’anglais comme langue. Cette étape garantit que le module de reconnaissance vocale démarre correctement et passe en mode d’écoute après avoir été activé par l’utilisateur.
Remarque : Actuellement, la reconnaissance vocale ne prend en charge que le chinois et l’anglais.
(2) Ajouter des mots clés de commande vocale
Utilisez l’instruction « ajouter un identifiant de commande vocale » pour attribuer un numéro d’identification unique à chaque commande vocale afin de faciliter sa reconnaissance et son traitement ultérieurs. Par exemple :
La commande « humidité maximale » se voit attribuer l’ID 0.
La commande « humidité minimale » se voit attribuer l’ID 1.
(3) Obtenir les valeurs d’humidité maximale et minimale
Au début du programme, créez deux variables, « hum_min » et « hum_max », pour stocker les valeurs minimales et maximales d’humidité. Utilisez la commande « read humidity » pour obtenir la valeur d’humidité initiale et assignez-la à « hum_min » et « hum_max ».
Créez une variable nommée « hum » pour acquérir en continu des données d’humidité en temps réel au sein de la boucle.
Utilisez la commande « si… alors… sinon » pour comparer les valeurs de « hum » et « hum_max ». Si « hum » est supérieur à « hum_max », mettez à jour « hum_max » avec la valeur de « hum ».
Sinon, si la condition est fausse, les données d’humidité maximale restent inchangées. Utilisez l’instruction « set hum_max to » pour affecter la valeur de la variable « hum_max » à la variable « hum_max ».
La méthode de comparaison des valeurs minimales d’humidité est la même que celle utilisée pour comparer les valeurs maximales d’humidité.
(4) Obtention des valeurs d’humidité maximale et minimale par commandes vocales
Pour obtenir les valeurs d’humidité maximale et minimale par commande vocale, il faut attendre que les graphiques linéaires soient entièrement tracés. Utilisez l’instruction « Si… alors » pour déterminer si la reconnaissance vocale est activée . Lorsque l’utilisateur prononce la phrase d’activation prédéfinie « Salut, Telly », la fonction de reconnaissance vocale passe en mode écoute et est prête à recevoir ses commandes vocales.
Si l’identifiant du mot de commande est détecté comme étant 0 (c’est-à-dire que l’utilisateur dit « humidité maximale »), utilisez l’instruction « afficher le contenu mis en cache » pour afficher la valeur la plus élevée comme « hum_max » à l’écran.
Si l’ID du mot de commande est détecté comme 1 (c’est-à-dire que l’utilisateur dit « humidité min »), utilisez l’instruction « afficher le contenu mis en cache » pour afficher l’humidité minimale comme « hum_max ».
Le programme complet est le suivant :
2. Exécution du programme
Avant d’exécuter le programme, veuillez vous assurer que l’UNIHIKER K10 est correctement connecté à l’ordinateur via le câble USB. Après avoir vérifié que tout est correct, cliquez sur le bouton « Exécuter » du logiciel. Une fois le programme exécuté avec succès, l’UNIHIKER K10 affichera un graphique linéaire d’humidité sur son écran. Une fois le graphique entièrement tracé, vous pouvez activer la reconnaissance vocale en disant « Salut Telly », puis prononcer la commande « humidité max ». L’écran affichera alors « Humidité max : ».
Remarque : Il existe deux phrases de réveil vocales : « Salut, Telly » et « Salut, Jarvis ».
Coin des connaissances
1. Contexte et importance de la surveillance environnementale intelligente
(1) La gravité des problèmes environnementaux
Avec le développement rapide de l’industrialisation et de l’urbanisation, les problèmes environnementaux sont devenus de plus en plus préoccupants. Des phénomènes tels que la pollution de l’air, la dégradation de la qualité de l’eau et la contamination des sols sont fréquents et constituent de graves menaces pour la santé et la qualité de vie des populations. Par exemple, le smog a entraîné une augmentation du nombre de patients souffrant de maladies respiratoires, et le rejet d’eaux usées industrielles a causé de graves dommages aux écosystèmes fluviaux. Dans ce contexte, les technologies de surveillance environnementale intelligente ont émergé. Elles permettent d’obtenir des données environnementales en temps réel et avec précision, fournissant ainsi une base scientifique à la gouvernance et à la protection de l’environnement.
(2) Limites de la surveillance environnementale traditionnelle
La surveillance environnementale traditionnelle repose principalement sur l’échantillonnage manuel et l’analyse en laboratoire, ce qui présente de nombreuses limites. Premièrement, la faible fréquence d’échantillonnage ne permet pas de refléter en temps réel l’évolution de la qualité de l’environnement. Deuxièmement, la répartition limitée des points d’échantillonnage rend difficile une couverture exhaustive de la zone surveillée. De plus, les analyses en laboratoire sont longues et ne permettent pas une prise de décision rapide. La technologie de surveillance environnementale intelligente pallie les lacunes de la surveillance traditionnelle grâce à l’utilisation de réseaux de capteurs, de l’Internet des objets (IoT) et de l’analyse des mégadonnées, permettant ainsi une surveillance automatisée, intelligente et en temps réel de l’environnement.
2. Tendances de développement de la surveillance environnementale intelligente
(1) Miniaturisation et intégration
Avec le développement de la microélectronique et des nanotechnologies, les capteurs de surveillance environnementale évoluent vers la miniaturisation et l’intégration. Les capteurs miniaturisés présentent l’avantage d’être de petite taille, peu gourmands en énergie et peu coûteux, ce qui facilite leur installation dans divers endroits et permet la création de réseaux de surveillance haute densité à grande échelle. Les modules de capteurs intégrés peuvent mesurer simultanément plusieurs paramètres environnementaux, améliorant ainsi l’efficacité de la surveillance et l’exhaustivité des données. Par exemple, l’intégration de capteurs de gaz, de température et d’humidité sur une seule puce permet une surveillance complète de la qualité de l’air.
(2) Intelligence et adaptabilité
Les futurs systèmes de surveillance environnementale intelligents seront dotés d’une intelligence accrue, leur permettant de reconnaître automatiquement les tendances des changements environnementaux et d’effectuer une surveillance adaptative. Grâce à l’apprentissage automatique et aux algorithmes d’intelligence artificielle, le système pourra ajuster automatiquement la fréquence et les paramètres de surveillance en fonction des variations des données environnementales. Par exemple, il pourra augmenter la fréquence de surveillance dans les zones où la qualité de l’air est mauvaise et la diminuer lorsque les conditions environnementales sont stables, ce qui permettra d’économiser de l’énergie et d’améliorer l’efficacité de la surveillance. Parallèlement, les systèmes de surveillance intelligents pourront également diagnostiquer automatiquement les pannes des capteurs et effectuer une autoréparation, améliorant ainsi la fiabilité et la stabilité du système.
(3) Intégration interdisciplinaire
Le développement de technologies intelligentes de surveillance environnementale nécessitera l’intégration de multiples disciplines, telles que les sciences de l’environnement, la physique, la chimie, la biologie, les sciences de l’information et l’informatique. Grâce à cette collaboration interdisciplinaire, il sera possible de développer des technologies et des équipements de surveillance environnementale plus performants et plus efficaces. Par exemple, l’association de la technologie des biocapteurs et de la vision par ordinateur permettra la surveillance en temps réel des polluants au sein des organismes vivants ; la mise à profit des avancées en sciences de l’environnement et en sciences de l’information contribuera à l’élaboration de modèles de prédiction de la qualité de l’environnement et de systèmes d’aide à la décision plus précis.
Relevez le défi
Puisque nous maîtrisons déjà la création de graphiques linéaires pour l’humidité, relevons un nouveau défi : créer simultanément des graphiques pour la luminosité et la température. Ce système de surveillance environnementale n’en sera que plus complet et pratique. Imaginez le plaisir de pouvoir observer intuitivement l’évolution de ces trois paramètres environnementaux clés – température, humidité et luminosité – sur un seul écran !