Catégories
Jeu vidéo ROBLOX ROBLOX-NIVEAU01

Rétrécir de plus en plus le joueur

A partir du tuto « Change la taille du joueur« 

Avec un cooldown

Quand un joueur touche une partie (ScalePart), son personnage rétrécit progressivement. Un cooldown (temps d’attente) empêche le joueur de rétrécir trop vite. Le script gère aussi plusieurs joueurs en même temps.

Comprendre le but du script

But :

  • Créer une partie (ScalePart) qui, quand un joueur la touche, réduit la taille de son personnage.
  • Limiter la fréquence de rétrécissement avec un cooldown (2 secondes).
  • Gérer plusieurs joueurs en même temps sans bugs.

Concepts clés :

  • Constantes : SCALESTEP, SCALEMINI, COOLDOWN.
  • Tableau associatif : cooldowns pour suivre l’état de chaque joueur.
  • Événements : Touched pour détecter quand un joueur touche la partie.
  • Conditions : Vérifier si un joueur peut rétrécir (if cooldowns[player]).

Le script

Voici le script commenté pour comprendre chaque partie :

-- Services et objets nécessaires
local Players = game:GetService("Players")  -- Service pour gérer les joueurs

local folder = workspace:WaitForChild("ScaleFolder")  -- Dossier contenant la partie
local part = folder:WaitForChild("ScalePart")  -- La partie à toucher

-- Variables globales
local SCALESTEP = 0.3  -- Réduction de la taille à chaque toucher
local SCALEMINI = 0.5  -- Taille minimum (le personnage ne peut pas rétrécir en dessous)
local COOLDOWN = 2     -- Temps d'attente (en secondes) avant de pouvoir rétrécir à nouveau

-- Tableau pour gérer les cooldowns des joueurs
-- Format : cooldowns[player] = true si le joueur subi déjà un rétrécissement, nil sinon
local cooldowns = {}

-- Détecter quand un joueur touche la partie
part.Touched:Connect(function(hit)
    -- Trouver le personnage du joueur qui a touché la partie
    local character = hit:FindFirstAncestorOfClass("Model")
    local player = character and Players:GetPlayerFromCharacter(character)

    -- Ignorer si ce n'est pas un joueur (ex: un mob, un débris)
    if not player then return end

    -- VÉRIFIER LE COOLDOWN : Si le joueur est déjà en cooldown, on arrête tout
    if cooldowns[player] then return end

    -- Trouver l'humanoïde du personnage (pour modifier sa taille)
    local humanoid = character:FindFirstChildOfClass("Humanoid")

    -- Si l'humanoïde n'existe pas ou si le personnage est déjà à la taille minimum, on arrête
    if not humanoid or humanoid.HeadScale.Value <= SCALEMINI then return end

    -- ACTIVER LE COOLDOWN pour ce joueur
    cooldowns[player] = true

    -- Réduire la taille du personnage (corps + tête)
    humanoid.BodyHeightScale.Value = math.max(SCALEMINI, humanoid.BodyHeightScale.Value - SCALESTEP)
    humanoid.BodyWidthScale.Value = math.max(SCALEMINI, humanoid.BodyWidthScale.Value - SCALESTEP)
    humanoid.BodyDepthScale.Value = math.max(SCALEMINI, humanoid.BodyDepthScale.Value - SCALESTEP)
    humanoid.HeadScale.Value = math.max(SCALEMINI, humanoid.HeadScale.Value - SCALESTEP)

    -- Après COOLDOWN secondes, réactiver la possibilité de rétrécir
    task.delay(COOLDOWN, function()
        cooldowns[player] = nil  -- Supprimer le cooldown pour ce joueur
    end)
end)

À toi de jouer !

  1. Copie ce script dans un Script dans Roblox Studio (par exemple, dans ServerScriptService).
  2. Crée les éléments nécessaires :
    • Un dossier ScaleFolder dans Workspace.
    • Une partie (Part) nommée ScalePart dans ce dossier.
  3. Teste le jeu :
    • Lance le jeu avec plusieurs joueurs (ou utilise le mode test avec 2 fenêtres).
    • Touche la ScalePart et observe :
      • Ton personnage rétrécit.
      • Tu ne peux pas rétrécir à nouveau avant 2 secondes.
      • Un autre joueur peut toucher la partie sans être bloqué par ton cooldown.

Explications détaillées

1. Pourquoi un cooldown ?

  • Problème sans cooldown :
    Si un joueur ou toutes ses parties touchent le part plusieurs fois en une seconde, son personnage rétrécirait trop vite (voire disparaîtrait !).
    Exemple : Sans cooldown, un joueur pourrait toucher la part 10 fois en 1 seconde et devenir minuscule instantanément.
  • Solution avec cooldown :
    Le script utilise cooldowns[player] = true pour bloquer le rétrécissement pendant 2 secondes (COOLDOWN = 2).
    Après ce délai, cooldowns[player] = nil permet au joueur de rétrécir à nouveau.
  • Analogie :
    Imagine que tu veux boire un verre d’eau, mais tu dois attendre 2 secondes entre chaque gorgée. Le cooldown, c’est comme ce temps d’attente !

2. Pourquoi un tableau cooldowns ?

  • Gérer plusieurs joueurs :
    Dans un jeu multijoueur, chaque joueur doit avoir son propre cooldown.
    Exemple : Si le joueur A touche la partie, seul son cooldown est activé. Le joueur B peut toujours toucher la partie.
  • Tableau associatif :
    cooldowns est un tableau où la clé est le player (joueur) et la valeur est true (en cooldown) ou nil (pas en cooldown).
    Exemple :luaCopiercooldowns = { [Player1] = true, -- Player1 est en cooldown [Player2] = nil -- Player2 peut rétrécir }
  • Pourquoi pas une variable simple ?
    Une variable comme isCooldown = true bloquerait tous les joueurs en même temps. Avec un tableau, chaque joueur a son propre état.

3. Autres concepts importants

  • math.max(SCALEMINI, value) :
    Garantit que la taille ne descend jamais en dessous de SCALEMINI (0.5).
    Exemple : Si humanoid.HeadScale.Value = 0.6 et SCALESTEP = 0.3, alors 0.6 - 0.3 = 0.3. Mais math.max(0.5, 0.3) retourne 0.5 (taille minimum).
  • FindFirstAncestorOfClass("Model") :
    Permet de remonter dans la hiérarchie de l’objet touché (hit) pour trouver le personnage (qui est un Model).
  • task.delay(COOLDOWN, function() ... end) :
    Exécute une fonction après un délai (COOLDOWN secondes). Ici, on réinitialise le cooldown du joueur.

QCM pour vérifier la compréhension

Sur le cooldown :

  1. À quoi sert le cooldown dans ce script ?
    • a) À empêcher le personnage de rétrécir trop vite.
    • b) À faire grandir le personnage.
    • c) À changer la couleur de la partie.
  2. Que se passe-t-il si on supprime if cooldowns[player] then return end ?
    • a) Le personnage rétrécira une fois, puis plus jamais.
    • b) Le personnage rétrécira trop vite (plusieurs fois par seconde).
    • c) Le jeu plantera.
  3. Pourquoi utilise-t-on task.delay(COOLDOWN, function() ... end) ?
    • a) Pour attendre 2 secondes avant de réactiver le cooldown.
    • b) Pour supprimer la partie.
    • c) Pour faire grandir le personnage.

Sur le tableau cooldowns :

  1. Pourquoi utilise-t-on un tableau cooldowns et pas une simple variable ?
    • a) Pour gérer chaque joueur individuellement.
    • b) Parce que c’est plus joli.
    • c) Pour économiser de la mémoire.
  2. Que contient cooldowns[player] quand un joueur est en cooldown ?
    • a) true
    • b) false
    • c) nil

Sur les conditions :

  1. À quoi sert math.max(SCALEMINI, humanoid.HeadScale.Value - SCALESTEP) ?
    • a) À garantir que la taille ne descend pas en dessous de SCALEMINI.
    • b) À faire grandir le personnage.
    • c) À changer la couleur du personnage.
  2. Pourquoi vérifie-t-on if not humanoid or humanoid.HeadScale.Value <= SCALEMINI ?
    • a) Pour empêcher le personnage de rétrécir s’il est déjà trop petit.
    • b) Pour le faire grandir.
    • c) Pour le faire disparaître.