Humanoid
*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.
L'humanoïde est un objet spécial qui donne aux modèles la fonctionnalité d'un personnage.Il accorde au modèle la capacité de se déplacer physiquement et d'interagir avec différents composants d'une expérience Roblox.Les humanoïdes sont toujours parentés à l'intérieur d'un Model , et le modèle est attendu pour être une assemblage de BasePart et Motor6D ; la partie racine de l'assemblage est attendue pour être nommée HumanoidRootPart .Il s'attend également à ce qu'une partie nommée Head soit connectée à la partie du torse du personnage, directement ou indirectement.Par défaut, il y a deux types officiels de rigs de personnage fournis par Roblox, chacun avec son propre ensemble de règles :
R6
- Un régime de caractère basique qui utilise 6 parties pour les membres.
- La partie Head doit être jointe à une partie nommée Torso ou l'Humanoïde mourra immédiatement.
- Les apparences de parties du corps sont appliquées en utilisant CharacterMesh objets.
- Certaines propriétés, telles que Humanoid.LeftLeg et Humanoid.RightLeg, ne fonctionnent que avec R6.
R15
- Plus complexe que R6, mais aussi beaucoup plus flexible et robuste.
- Utilise 15 parties pour les membres.
- La partie Head doit être jointe à une partie nommée UpperTorso ou l'Humanoïde mourra immédiatement.
- Les apparences de parties du corps doivent être assemblées directement.
- Peut être redimensionné dynamiquement en utilisant des objets spéciaux NumberValue parentés à l'intérieur du Humanoïde.
- L'humanoïde créera automatiquement des objets nommés à l'intérieur de chaque membre.
- Si une valeur numérique est héritée à l'intérieur du Humanoïde et est nommée l'une des suivre, elle sera utilisée pour contrôler la fonctionnalité de mise à l'échelle :
- Échelle de profondeur du corps
- Taille du corpsHeightScale
- Échelle de largeur du corps
- Taille de tête
Échantillons de code
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
local RunService = game:GetService("RunService")
local playerModel = script.Parent
local humanoid = playerModel:WaitForChild("Humanoid")
local function updateBobbleEffect()
local now = tick()
if humanoid.MoveDirection.Magnitude > 0 then -- Is the character walking?
local velocity = humanoid.RootPart.Velocity
local bobble_X = math.cos(now * 9) / 5
local bobble_Y = math.abs(math.sin(now * 12)) / 5
local bobble = Vector3.new(bobble_X, bobble_Y, 0) * math.min(1, velocity.Magnitude / humanoid.WalkSpeed)
humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, 0.25)
else
-- Scale down the CameraOffset so that it shifts back to its regular position.
humanoid.CameraOffset = humanoid.CameraOffset * 0.75
end
end
RunService.RenderStepped:Connect(updateBobbleEffect)
Résumé
Propriétés
Défini si le personnage sautera automatiquement lorsqu'il heurtera un obstacle en tant que joueur sur un appareil mobile.
AutoRotate définit si oui ou non le Humanoïde tournera automatiquement vers la direction dans laquelle il se déplace.
Lorsqu'il est activé, AutomaticScalingEnabled provoque le changement de la taille du personnage en réponse aux valeurs des échelles enfant de l'humanoïde qui changent.
Détermine si les articulations de l'humanoïde se brisent lorsqu'il se trouve dans l'état Enum.HumanoidStateType.Dead.
Un décalage appliqué à la position du sujet de la caméra lorsque sa position de caméra sujet est définie sur cet humanoïde.
Contrôle le comportement de la distance de la santé et du nom de l'humanoïde.
Définit le texte d'un humanoïde, affiché au-dessus de sa tête.
Décrit le Enum.Material sur lequel le Humanoid se trouve actuellement debout.Si le Humanoid n'est pas sur quelque chose, la valeur de cette propriété sera Air.
Décrit l'état de santé actuel de l'Humanoïde sur la portée [0, Humanoid.MaxHealth].
Utilisé en conjonction avec la propriété DisplayDistanceType pour contrôler la distance à partir de laquelle la barre de santé d'un humanoïde peut être vue.
Contrôles lorsque la barre de santé de l'humanoïde peut être affichée.
Détermine la distance hors du sol que le Humanoid.RootPart devrait être.
Si true , le Humanoid saute avec une force vers le haut.
Fournit un contrôle sur la hauteur à laquelle les sauts Humanoid sautent.
Détermine la quantité de force vers le haut appliquée au Humanoid lors du saut.
La valeur maximale d'un humanoïde Health .
L'angle de pente maximum sur lequel un humanoïde peut marcher sans glisser.
Décrit la direction dans laquelle le Humanoid marche.
Utilisé en conjonction avec la propriété Humanoid.DisplayDistanceType pour contrôler la distance à partir de laquelle le nom d'un humanoïde peut être vu.
Contrôle si la barre de nom et de santé d'un humanoïde peut être vue derrière des murs ou d'autres objets.
Détermine si le Humanoid est actuellement dans l'état Enum.HumanoidStateType.PlatformStanding.
Permet aux développeurs de désactiver le comportement où un joueur Character|character si la nuque Motor6D ou déconnectée même momentanément.
Détermine si cette Humanoid utilise le caractère hérité R6 ou le nouveau plateforme.
Une référence à l'objet Racine humanoïde du humanoïde.
Une référence au siège sur lequel un Humanoid est actuellement assis, si nécessaire.
Détermine si le Humanoid est actuellement assis.
Décrit la position 3D où le Player contrôle le Humanoid dernier cliqué dans le monde en utilisant un Tool.
Détermine si la propriété JumpHeight (fausse) ou Humanoid.JumpPower (vraie) est utilisée.
Détermine la vitesse de déplacement maximale de l'humanoïde en studs par seconde.
Une référence à une partie dont la position est essayer d'être atteinte par un humanoïde
La position qu'un humanoïde essaie d'atteindre, après un appel à Humanoid:MoveTo() est fait.
Méthodes
Attache le Accessory au parent de l'humanoïde.
Assemble un arbre de jointures en attachant ensemble des objets dans le personnage d'un humanoïde.
Définit le Humanoid pour entrer le Enum.HumanoidStateType donné.
Renvoie un ensemble d'objets Accessory de l'humanoïde que le parent porte actuellement.
Renvoie une copie du cache de l'humanoïde HumanoidDescription qui décrit son apparence actuelle.
Passez une partie du corps à cette méthode (la partie du corps devrait être un frère d'Humanoïde et un enfant d'un modèle) pour obtenir le Enum.BodyPartR15 de la Part.
Retourne l'actuel Enum.HumanoidStateType de l'humanoïde.
Renvoie si un Enum.HumanoidStateType est activé pour le Humanoid.
Fait en sorte que le Humanoid marche dans la direction donnée.
Fait en sorte que le Humanoid marche vers l'emplacement donné en définissant les propriétés Humanoid.WalkToPoint et Humanoid.WalkToPart.
Supprime tous les objets Accessory portés par le parent de l'humanoïde
Remplace dynamiquement une partie du corps humanoïde par une partie différente.
Définit si un donné Enum.HumanoidStateType est activé pour le Humanoid.
Baisse le Humanoid.Health du Humanoid par le montant donné ** si il n'est pas protégé par un ForceField.
Déséquipe n'importe quel Tool actuellement équipé par le Humanoid .
- ApplyDescription(humanoidDescription : HumanoidDescription,assetTypeVerification : Enum.AssetTypeVerification):()
Fait correspondre l'apparence du personnage à celle du passe dans HumanoidDescription.
- ApplyDescriptionReset(humanoidDescription : HumanoidDescription,assetTypeVerification : Enum.AssetTypeVerification):()
Fait correspondre l'apparence du personnage à celle du passe dans HumanoidDescription, même après des modifications externes.
Joue des émotes et renvoie si elle a été exécutée avec succès.
Évènements
S'enflamme lorsque la vitesse à laquelle un Humanoid monte change.
S'enflamme lorsque le Humanoid meurt.
S'enflamme lorsque le Humanoid entre ou quitte le FallingDown``Enum.HumanoidStateType .
S'enflamme lorsque le Humanoid entre ou quitte le Freefall``Enum.HumanoidStateType .
S'enflamme lorsque le Humanoid entre ou quitte le GettingUp``Enum.HumanoidStateType .
Se déclenche lorsque les modifications de Humanoid.Health changent (ou lorsque le Humanoid.MaxHealth est configurer).
S'enflamme lorsque le Humanoid entre et quitte le Jumping``Enum.HumanoidStateType .
S'enflamme lorsque le Humanoid finit de marcher vers un objectif déclaré par Humanoid:MoveTo().
S'enflamme lorsque le Humanoid entre ou quitte le PlatformStanding``Enum.HumanoidStateType .
S'enflamme lorsque le Humanoid entre ou quitte le Ragdoll``Enum.HumanoidStateType .
S'enflamme lorsque la vitesse à laquelle un Humanoid est en cours d'exécution change.
Tiré lorsqu'un est assis dans un ou se lève.
S'enflamme lorsque l'état du Humanoid est modifié.
S'enflamme lorsque Humanoid:SetStateEnabled() est appelé sur le Humanoid.
S'enflamme lorsque le Humanoid entre ou quitte le StrafingNoPhysics``Enum.HumanoidStateType .
S'enflamme lorsque la vitesse à laquelle un Humanoid nage dans l'eau change de Terrain.
Se déclenche lorsque l'une des membres d'un humanoïde entre en contact avec un autre BasePart.
Propriétés
AutoJumpEnabled
AutoJumpEnabled détermine si oui ou non le Humanoid sautera automatiquement sur un obstacle vers lequel il marche.
Actuellement, cette propriété ne fonctionne que lorsque les conditions suivantes sont vraies :
- Le modèle de caractère de l'humanoïde est le Player.Character d'un Player.
- Le joueur en question utilise des contrôles tactiles.
Lorsque le personnage d'un joueur apparaît, la valeur de la propriété correspond à la propriété du joueur Player.AutoJumpEnabled - qui à son tour correspond à la propriété StarterPlayer.AutoJumpEnabled.
Échantillons de code
This code sample is meant for a TextButton. It allows the player to toggle the auto-jumping behavior while on a mobile device.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local button = script.Parent
local function update()
-- Update button text
if player.AutoJumpEnabled then
button.Text = "Auto-Jump is ON"
else
button.Text = "Auto-Jump is OFF"
end
-- Reflect the property in the player's character, if they have one
if player.Character then
local human = player.Character:FindFirstChild("Humanoid")
if human then
human.AutoJumpEnabled = player.AutoJumpEnabled
end
end
end
local function onActivated()
-- Toggle auto-jump
player.AutoJumpEnabled = not player.AutoJumpEnabled
-- Update everything else
update()
end
button.Activated:Connect(onActivated)
update()
AutoRotate
La propriété AutoRotate décrit si oui ou non le Humanoïde tournera automatiquement vers la direction dans laquelle il se déplace.Lorsqu'il est réglé sur vrai, le modèle de caractère se tournera progressivement vers leur direction de mouvement à mesure que l'Humanoïde se déplace.Lorsqu'il est défini sur false, le modèle de caractère restera fixé dans sa rotation actuelle, à moins qu'une force de rotation ne soit appliquée à la partie racine humanoïde.
Si le modèle de caractère se trouve être le personnage d'un joueur, alors le comportement de la rotation de l'humanoïde est influencé par la propriété RotateType du paramètre UserGameSetting.
Lorsque la propriété AutoRotate est définie sur true, la propriété RotateType a les effets suivants sur la rotation de l'Humanoïde :
<th>Comportement</th><th>Contexte</th></tr></thead><tbody><tr><td>MouvementRelatif</td><td /><td /></tr><tr><td>Caméra relative</td><td>Le personnage tournera pour faire face dans la direction de la caméra.</td><td>Le joueur a sa caméra zoomée en première personne, ou il est en mode verrouillage de changement de vitesse.</td></tr></tbody>
Type de rotation |
---|
Échantillons de code
This script adds the functionality of a button to a part, which switches the AutoRotate property of whoever touches it.
local button = script.Parent
local enabled = true
local ON_COLOR = BrickColor.Green()
local OFF_COLOR = BrickColor.Red()
local function touchButton(humanoid)
if enabled then
enabled = false
button.BrickColor = OFF_COLOR
if humanoid.AutoRotate then
print(humanoid:GetFullName() .. " can no longer auto-rotate!")
humanoid.AutoRotate = false
else
print(humanoid:GetFullName() .. " can now auto-rotate!")
humanoid.AutoRotate = true
end
task.wait(1)
button.BrickColor = ON_COLOR
enabled = true
end
end
local function onTouched(hit)
local char = hit:FindFirstAncestorWhichIsA("Model")
if char then
local humanoid = char:FindFirstChildOfClass("Humanoid")
if humanoid then
touchButton(humanoid)
end
end
end
button.Touched:Connect(onTouched)
button.BrickColor = ON_COLOR
AutomaticScalingEnabled
L'humanoïde a six valeurs d'échelle enfant, y compris BodyDepthScale , BodyHeightScale , BodyProportionScale , BodyTypeScale , BodyWidthScale , HeadScale .Changer la valeur de l'une de ces causes provoque le changement des parties du corps et des accessoires du personnage, mais seulement si AutomaticScalingEnabled est vrai.
BreakJointsOnDeath
Détermine si les articulations de l'humanoïde se brisent lorsqu'il se trouve dans l'état Enum.HumanoidStateType.Dead. Par défaut, c'est vrai.
CameraOffset
La propriété CameraOffset spécifie un décalage par rapport à la position du sujet de la caméra lorsque son Camera.CameraSubject est réglé sur cette Humanoid.
L'offset est appliqué dans l'espace d'objet, par rapport à l'orientation de la partie racine humanoïde de HumanoidRootPart .Par exemple, une valeur d'offset Vector3 de (0, 10, 0) déplace la caméra du joueur à 10 studs au-dessus du humanoid du joueur.
Échantillons de code
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
local RunService = game:GetService("RunService")
local playerModel = script.Parent
local humanoid = playerModel:WaitForChild("Humanoid")
local function updateBobbleEffect()
local now = tick()
if humanoid.MoveDirection.Magnitude > 0 then -- Is the character walking?
local velocity = humanoid.RootPart.Velocity
local bobble_X = math.cos(now * 9) / 5
local bobble_Y = math.abs(math.sin(now * 12)) / 5
local bobble = Vector3.new(bobble_X, bobble_Y, 0) * math.min(1, velocity.Magnitude / humanoid.WalkSpeed)
humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, 0.25)
else
-- Scale down the CameraOffset so that it shifts back to its regular position.
humanoid.CameraOffset = humanoid.CameraOffset * 0.75
end
end
RunService.RenderStepped:Connect(updateBobbleEffect)
DisplayDistanceType
La propriété DisplayDistanceType contrôle le comportement de la distance de la distance du nom et de l'affichage de la santé de l'humanoïde.Cette propriété est définie en utilisant l'enum Enum.HumanoidDisplayDistanceType avec trois valeurs disponibles, chacune avec son propre ensemble de règles :
- Lorsqu'il est réglé sur Viewer, l'humanoïde voit le nom/la santé des autres humanoïdes dans la portée de son propre NameDisplayDistance et HealthDisplayDistance .
- Lorsqu'il est défini à , l'humanoïde prend le contrôle complet de son propre nom et de son affichage de santé à travers ses valeurs et .
- Lorsqu'il est défini à None, la barre de nom et de santé de l'humanoïde n'apparaît pas dans toutes les circonstances.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
Échantillons de code
This example demonstrates how to set a Humanoid's Humanoid.DisplayerDistanceType, Humanoid.HealthDisplayDistance, and Humanoid.NameDisplayDistance properties. These properties determine how a humanoid's healthbar and name are rendered for a player.
First, we change the DisplayDistanceType to Viewer using Enum.HumanoidDisplayDistanceType. When set to viewer, the humanoid's Name and healthbar will be displayed based on the distance settings of the humanoid viewing them.
Then, the humanoid's HealthDisplayDistance is set to 0. Setting the property to 0 hides the healthbar completely. It is not displayed at any distance.
Finally, the humanoid's NameDisplayDistance is set to 100. This means that the humanoid's name will be visible to other humanoid's within 100 studs.
This example should work as expected when placed inside a Script that is a child of the humanoid.
local humanoid = script.Parent
humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.Viewer
humanoid.HealthDisplayDistance = 0
humanoid.NameDisplayDistance = 100
DisplayName
DisplayName est une propriété qui détermine l'affichage du nom de l'Humanoïde lorsqu'il est visible.Par défaut, un nouvel humanoïde aura la valeur d'une chaîne vide.Si DisplayName est une chaîne vide, l'affichage du nom de l'humanoïde sera par défaut la propriété du nom du parent de l'humanoïde.
Chargement du personnage du joueur
Lorsque les joueurs chargent leur personnage, soit automatiquement soit via l'utilisation de LoadCharacter() , l'Humanoïde créé par le moteur aura sa propriété DisplayName définie sur la propriété du joueur DisplayName.
Personnage de départ et StarterHumanoid
Lorsqu'un Humanoid nommé StarterHumanoid est parenté à StarterPlayer , ou lorsqu'un Humanoïde est présent dans un modèle nommé StarterCharacter , la propriété DisplayName sera respectée lorsque les caractères sont chargés par les joueurs dans le jeu.Le moteur ne remplacera que la propriété DisplayName de l'Humanoïde par la propriété DisplayName du joueur si la propriété Humanoid.DisplayName de StarterHumanoid est une chaîne vide.
EvaluateStateMachine
FloorMaterial
C'est une propriété de lecture seule qui décrit le Enum.Material le Humanoid est actuellement en place.Il fonctionne avec les voxels réguliers Parts et Terrain ainsi que les voxels.
L'exemple de code ci-dessous montre comment écouter lorsque cette propriété change en utilisant Object:GetPropertyChangedSignal() .Lorsque le matériau sur lequel se tient l'humanoïde change, il imprimera un message indiquant le nouveau matériau sur lequel il se tient.
local Humanoid = route.to.humanoid
Humanoid:GetPropertyChangedSignal("FloorMaterial"):Connect(function()
print("New value for FloorMaterial: " .. tostring(Humanoid.FloorMaterial))
end)
Avertissements
- Lorsque le Humanoid n'est pas sur un étage, la valeur de cette propriété sera définie sur Air.
- Cela se produit parce que les propriétés Enum ne peuvent pas avoir de valeur vide.
- Cela peut causer une certaine confusion si une partie a son matériau réglé sur Air, bien que, en pratique, les parties ne soient pas censées utiliser ce matériau en premier emplacement.
- Le modèle de caractère de la Humanoid doit être capable de s'écraser avec le sol, sinon il ne sera pas détecté.
- Vous ne pouvez pas tester si le Humanoid nage avec cette propriété. Vous devez plutôt utiliser sa fonction Humanoid:GetState().
Health
Cette propriété représente l'état de santé actuel du Humanoid.La valeur est restreinte à la plage entre 0 et MaxHealth .Si l'humanoïde est mort, cette propriété est constamment définie à 0.
Notez que la fonction TakeDamage() peut être utilisée pour soustraire de Health au lieu de définir la propriété directement.
Régénération de la santé
Par défaut, un script de régénération de santé passive est automatiquement inséré dans les humanoïdes.Cela provoque la régénération de 1% des personnages non morts à chaque seconde de MaxHealth.Pour désactiver ce comportement de régénération, ajoutez un vide Script nommé santé à StarterCharacterScripts .
Affichage de la barre de santé
Lorsque Health est inférieur à MaxHealth, une barre de santé est affichée dans l'expérience.Le comportement d'affichage de la barre de santé dépend de la HealthDisplayDistance et de la HealthDisplayType.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
Mort
Lorsque la valeur de la santé du personnage atteint 0, la valeur Humanoid migre automatiquement vers l'état Enum.HumanoidStateType.Dead.Dans cet état, Health est verrouillé à 0 ; cependant, il n'y a pas d'erreur ou d'avertissement pour définir le Health d'un humanoïde mort à une valeur positive non nulle.
HealthDisplayDistance
Cette propriété est un nombre utilisé en conjonction avec la propriété DisplayDistanceType pour contrôler la distance à partir de laquelle la barre de santé d'un humanoïde peut être vue.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
HealthDisplayType
Cette propriété contrôle quand la barre de santé d'un humanoïde peut être affichée.Par défaut, cette propriété est définie à , ce qui fait que la barre de santé ne s'affiche que lorsque la santé d'un humanoïde est inférieure à sa .Il peut également être réglé sur AlwaysOn , ce qui fait en sorte que la barre de santé s'affiche toujours, ou AlwaysOff , ce qui l'empêche de s'afficher jamais.
Notez que cette propriété fonctionne indépendamment de la propriété humanoid de HealthDisplayDistance qui est responsable de faire disparaître la barre de santé à certaines distances.Si Humanoid.HealthDisplayType|HealthDisplayType est réglé sur AlwaysOn, il disparaîtra toujours en fonction de la manière dont HealthDisplayDistance est configuré.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
HipHeight
Détermine la distance (en studs) hors du sol que le RootPart devrait être lorsque l'humanoïde se tient debout.La RigType influence la façon dont cette propriété se comporte.
Pour les équipages R15, une hauteur de hanche appropriée est prédéfinie pour garantir que la hauteur du RootPart est correcte.La hauteur des jambes n'est pas utilisée.La hauteur globale de l'humanoïde peut être décrite dans la formule suivante :
Height = (0.5 * RootPart.Size.Y) + HipHeight
Pour les rigs R6, HipHeight décrit plutôt un décentragerelatif. La hauteur globale de l'humanoïde peut être décrite dans la formule suivante :
Height = LeftLeg.Size.Y + (0.5 * RootPart.Size.Y) + HipHeight
Jump
Si true , le saut Humanoid s'effectue avec une force vers le haut égale à la valeur de Humanoid.JumpPower ou à la hauteur de Humanoid.JumpHeight , selon la valeur de Humanoid.UseJumpPower .
JumpHeight
Fournit le contrôle de la hauteur d'un saut Humanoid en studs.La valeur de départ de cette propriété est déterminée par la valeur de StarterPlayer.CharacterJumpHeight qui est définie par défaut sur 7.2.
Bien que définir cette propriété à 0 empêchera effectivement le humanoïde de sauter, il est recommandé de désactiver le saut en désactivant l'état Enum.HumanoidStateType.Jumping par le biais de Humanoid:SetStateEnabled() .
Cette propriété n'est visible que dans la fenêtre propriétés si Humanoid.UseJumpPower est réglée sur faux , car elle ne serait pas pertinente autrement (au lieu de cela, Humanoid.JumpPower est utilisé).
JumpPower
Détermine la quantité de force vers le haut appliquée au Humanoid lors du saut.La valeur de départ de cette propriété est déterminée par la valeur de StarterPlayer.CharacterJumpPower qui est par défaut à 50 et est limitée entre 0 et 1000.Remarquez que les sauts sont également influencés par la propriété Workspace.Gravity qui détermine l'accélération due à la gravité.
Bien que définir cette propriété à 0 empêchera effectivement le humanoïde de sauter, il est recommandé de désactiver le saut en désactivant l'état Enum.HumanoidStateType.Jumping par le biais de Humanoid:SetStateEnabled() .
Cette propriété n'est visible que dans la fenêtre propriétés si Humanoid.UseJumpPower est réglée sur vrai , car elle ne serait pas pertinente autrement (au lieu de cela, Humanoid.JumpHeight est utilisé).
MaxHealth
La valeur maximale d'un humanoïde Health .
La valeur de cette propriété est utilisée aux côtés de la propriété Health pour dimensionner l'affichage de la barre de santé par défaut.Lorsque la barre de santé d'un humanoïde atteint Health , sa propriété MaxHealth peut ne pas être affichée, en fonction de sa propriété HealthDisplayType.
MaxSlopeAngle
Cette propriété détermine l'angle de pente maximum que peut escalader un humanoïde.Si l'angle d'une pente est supérieur à l'angle maximum d'une humanoid, ils glisseront le long de la pente.
Lorsqu'un personnage apparaît, cette propriété est définie selon la valeur de StarterPlayer.CharacterMaxSlopeAngle .
La valeur de cette propriété est limitée aux valeurs entre 0° et 89°.Il se définit par défaut sur 89°, de sorte que les humanoïdes peuvent escalader pratiquement n'importe quelle pente qu'ils souhaitent par défaut.
Échantillons de code
The example below demonstrates the effect of the MaxSlopAngle property by limiting the maximum slope the Players.LocalPlayer can walk up to 30°. The local player will slide down any slope greater than 30°.
This code below works as expected when placed in a LocalScript.
local player = game.Players.LocalPlayer
local char = player.CharacterAdded:wait()
local h = char:FindFirstChild("Humanoid")
h.MaxSlopeAngle = 30
MoveDirection
MoveDirection est une propriété de lecture seule qui décrit la direction dans laquelle un Humanoid marche, en tant que vecteur d'unité ou force vectoriellede longueur zéro.La direction est décrite dans l'espace du monde.
Comme cette propriété est lectible seule, elle ne peut être définie par un Script ou LocalScript .
Échantillons de code
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
local RunService = game:GetService("RunService")
local playerModel = script.Parent
local humanoid = playerModel:WaitForChild("Humanoid")
local function updateBobbleEffect()
local now = tick()
if humanoid.MoveDirection.Magnitude > 0 then -- Is the character walking?
local velocity = humanoid.RootPart.Velocity
local bobble_X = math.cos(now * 9) / 5
local bobble_Y = math.abs(math.sin(now * 12)) / 5
local bobble = Vector3.new(bobble_X, bobble_Y, 0) * math.min(1, velocity.Magnitude / humanoid.WalkSpeed)
humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, 0.25)
else
-- Scale down the CameraOffset so that it shifts back to its regular position.
humanoid.CameraOffset = humanoid.CameraOffset * 0.75
end
end
RunService.RenderStepped:Connect(updateBobbleEffect)
NameDisplayDistance
La propriété NomAffichageDistance est un nombre utilisé en conjonction avec la propriété Humanoid.DisplayDistanceType pour contrôler la distance à partir de laquelle le nom d'un humanoïde peut être vu.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
NameOcclusion
Contrôle si la barre de nom et de santé d'un humanoïde peut être vue derrière des murs ou d'autres objets.Cette propriété est une valeur Enum.NameOcclusion et peut être configurée pour exclure tous les noms, les noms des ennemis ou désactiver l'exclusion entièrement.
Dans les cas où le LocalPlayer n'a pas de Humanoid associé, cette propriété s'applique plutôt au sujet Humanoid.
Voir nom du personnage/affichage de la santé pour un guide détaillé sur le contrôle de l'apparence des noms de personnages et des barres de santé.
Échantillons de code
In the below example, Player|Players will not be able to see each other's Player.Character names when they are obscured behind BasePart|BaseParts.
local Players = game:GetService("Players")
local function onCharacterAdded(character)
local humanoid = character:WaitForChild("Humanoid")
humanoid.NamOcclusion = Enum.NameOcclusion.OccludeAll
end
local function onPlayerAdded(player)
player.CharacterAdded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
PlatformStand
Détermine si le Humanoid est actuellement dans l'état Enum.HumanoidStateType.PlatformStanding.Lorsque c'est vrai, l'Humanoïde est dans un état où il tombe librement et ne peut pas mouvement.Cet état se comporte de manière similaire à la position assise, sauf que le saut ne libère pas l'humanoïde de l'état.
RequiresNeck
Permet aux développeurs de désactiver le comportement où un joueur Character|character si la nuque Motor6D ou déconnectée même momentanément.Cette propriété est définie par défaut sur true.
RigType
RigType décrit si un Humanoid utilise le plateformede caractères hérité R6 ou le plateformede caractères R15 plus récent.
Le rig R6 utilise 6 visibles Parts alors que le rig R15 utilise 15 visibles Parts .Les rigs R15 ont plus de jointures que les rigs R6, ce qui les rend beaucoup plus polyvalents lorsqu'ils sont animés.
Notez que si cette propriété est définie incorrectement, le Humanoid ne fonctionnera pas correctement.Par exemple, si le type de rigueur d'un humanoïde R15 RigType est réglé sur R6, le Humanoid mourra car il n'y a pas de BasePart appelé Torso connecté à un BasePart appelé Tête .
RootPart
Une référence à l'objet HumanoidRootPart du humanoïde, la partie racine du Humanoid qui contrôle le mouvement d'un humanoïde dans le monde 3D.Cette partie est normalement invisible.
Pour les personnages R15, Model.PrimaryPart de la modèle Player.Character est défini sur HumanoidRootPart .
Pour les caractères R6, Model.PrimaryPart est défini sur la partie Head.
SeatPart
SeatPart est une référence au siège dans lequel un Humanoid est actuellement assis, si nécessaire.La valeur de cette propriété peut être un Seat ou un VehicleSeat .Ce sera zéro si l'Humanoïde n'est pas actuellement assis sur un siège.
Remarque :
- Pour un bool décrivant si le Humanoid est actuellement assis ou non, voir Humanoid.Sit
Sit
La propriété Sit est un booléen qui indique si le Humanoid est actuellement assis.Humanoids peut être forcé dans un état assis en définissant la valeur de cette propriété sur vrai.Si le Humanoid n'est pas attaché à un siège lors de son état assis, il trébuchera sans collision dans ses jambes.Un Humanoid peut s'échapper de l'état assis en sautant.
Remarque :
- Le Seat ou VehicleSeat le Humanoid est assis sur peut être obtenu en utilisant la propriété Humanoid.SeatPart
- Il est possible de détecter quand un humanoïde s'assied en se connectant à l'événement Humanoid.Seated.
TargetPoint
Ne pas utiliser Cette propriété ne fonctionne qu'avec le mode expérimental activé, qui a été entièrement abandonné.
Cette propriété décrit une position 3D dans l'espace où la Player contrôle cette Humanoid dernière a été cliquée avec un Tool équipé.
Cette propriété est principalement utilisée par les outils classiques pour déterminer ce qu'un humanoïde vise lorsqu'il active un outil.Si vous donnez à un PNJ un lance-roquettes classique, définissez leur point cible , puis appelez la fonction Tool:Activate() de l'outil, vous pouvez faire en sorte que le PNJ tire une roquette au point cible.
UseJumpPower
Lorsqu'un personnage apparaît, cette propriété est définie selon la valeur de StarterPlayer.CharacterUseJumpPower qui est définie sur true par défaut.
Lors du saut, avec cette valeur définie sur vrai, la valeur Humanoid.JumpHeight est utilisée pour assurer les sauts humanoïdes à cette hauteur.Avec ce paramètre défini sur false, la valeur Humanoid.JumpPower est utilisée pour appliquer une force ascendante.
WalkSpeed
Cette propriété décrit la vitesse à laquelle la Humanoid peut marcher, en studs par seconde.Il défaut à la valeur de StarterPlayer.CharacterWalkSpeed (16), ce qui signifie qu'un personnage de joueur peut se déplacer de 16 studs dans n'importe quelle direction à chaque seconde.
Notations
- Lorsqu'il est contrôlé sur un appareil mobile ou une manette de gamepad, un humanoïde peut marcher plus lentement que son WalkSpeed si le joystick de contrôle est déplacé d'un degré graduel vers le centre.
- Vous pouvez geler un humanoïde en place en définissant WalkSpeed à 0 ; cela empêche le joueur de contrôle de le déplacer par le biais des mécanismes de mouvement par défaut.
- Le script d'animation par défaut échelle les animations de mouvement d'un humanoïde en fonction de la vitesse à laquelle il se déplace par rapport à la vitesse par défaut de 16 studs/seconde.
WalkToPart
WalkToPart est une référence à une partie que l'Humanoïde essaie d'atteindre.Cette propriété est normalement définie lorsqu'une partie est passée en tant que deuxième argument de la fonction Humanoid:MoveTo() de l'Humanoïde.
Lorsque WalkToPart est défini et qu'un humanoïde essaie activement d'atteindre la partie, il gardera à jour son objectif Vector3 pour être la position de la partie, plus le Humanoid.WalkToPoint traduit dans l'espace d'objet par rapport à la rotation de la partie.
Cela peut être décrit dans Luau comme :
goal = humanoid.WalkToPart.CFrame:pointToObjectSpace(humanoid.WalkToPoint)
Avertissements
- Définir la valeur de WalkToPart n'est pas suffisant pour faire démarrer un humanoïde après une partie.
- L'humanoïde est invité à commencer à essayer d'atteindre un objectif lorsque la valeur de WalkToPoint est modifiée.
- Cela peut être modifié à l'avenir.
- L'état de atteindre l'objectif d'un humanoïde expirera après 8 secondes s'il ne parvient pas à son objectif.
- Cela est fait pour que les PNJ ne soient pas coincés en attendant que Humanoid.MoveToFinished lancer.
- Si vous ne voulez pas que cela se produise, vous devez appeler à plusieurs reprises MoveTo afin que l'expiration se réinitialise à nouveau.
WalkToPoint
WalkToPoint décrit la position 3D dans l'espace que cherche à atteindre un humanoïde, après avoir été invité à le faire par la fonction Humanoid:MoveTo() de l'humanoïde.
Si la Humanoid.WalkToPart d'un humanoïde est configurer, l'objectif est défini en transformant WalkToPoint par rapport à la position et la rotation des parties.Si WalkToPart n'est pas configurer, l'humanoïde essaiera d'atteindre la position 3D spécifiée par WalkToPoint directement.
Avertissements
- La valeur de WalkToPoint doit être modifiée pour qu'un humanoïde commence à marcher vers elle.
- Si vous voulez faire une promenade humanoïde à 0,0,0 , vous devez utiliser la fonction MoveTo de l'humanoïde.
- Cela peut être modifié à l'avenir.
- L'état de atteindre l'objectif d'un humanoïde expirera après 8 secondes s'il ne parvient pas à son objectif.
- Cela est fait pour que les PNJ ne soient pas coincés en attendant que Humanoid.MoveToFinished lancer.
- Si vous ne voulez pas que cela se produise, vous devez appeler à plusieurs reprises MoveTo afin que l'expiration se réinitialise à nouveau.
Échantillons de code
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
local function moveTo(humanoid, targetPoint, andThen)
local targetReached = false
-- listen for the humanoid reaching its target
local connection
connection = humanoid.MoveToFinished:Connect(function(reached)
targetReached = true
connection:Disconnect()
connection = nil
if andThen then
andThen(reached)
end
end)
-- start walking
humanoid:MoveTo(targetPoint)
-- execute on a new thread so as to not yield function
task.spawn(function()
while not targetReached do
-- does the humanoid still exist?
if not (humanoid and humanoid.Parent) then
break
end
-- has the target changed?
if humanoid.WalkToPoint ~= targetPoint then
break
end
-- refresh the timeout
humanoid:MoveTo(targetPoint)
task.wait(6)
end
-- disconnect the connection if it is still connected
if connection then
connection:Disconnect()
connection = nil
end
end)
end
local function andThen(reached)
print((reached and "Destination reached!") or "Failed to reach destination!")
end
moveTo(script.Parent:WaitForChild("Humanoid"), Vector3.new(50, 0, 50), andThen)
Méthodes
AddAccessory
Cette méthode attache le Accessory spécifié au parent de l'humanoïde.
Lorsque cette méthode est appelée, un Accessory est attaché au personnage en recherchant un Attachment dans le parent d'un humanoïde qui partage le même nom qu'un Attachment dans la poignée de l'accesoire Handle Part .Si l'on en trouve une, la partie poignée sera connectée au parent du Attachment en utilisant un Weld , et le soudage sera configuré afin que le Attachments occupe le même espace.
Si le Attachment requis ne peut être trouvé, alors le Accessory restera parenté au parent de l'humanoïde mais il sera détaché.
Typiquement, les soudures accessoires sont créées sur le serveur, mais elles peuvent être créées sur le client dans certaines circonstances.Dans ces situations, les appels côté client à AddAccessory() peuvent ne pas toujours produire le comportement souhaité et vous pouvez utiliser BuildRigFromAttachments() pour forcer la créationsde soudure attendue.
Paramètres
Retours
Échantillons de code
This script generates the "Clockwork's Shades" Accessory from scratch, and then attaches it to the player's character using Humanoid.AddAccessory You should paste this code into a regular script, and then parent it inside of the StarterPlayer's StarterCharacterScripts folder.
local playerModel = script.Parent
local humanoid = playerModel:WaitForChild("Humanoid")
local clockworksShades = Instance.new("Accessory")
clockworksShades.Name = "ClockworksShades"
local handle = Instance.new("Part")
handle.Name = "Handle"
handle.Size = Vector3.new(1, 1.6, 1)
handle.Parent = clockworksShades
local faceFrontAttachment = Instance.new("Attachment")
faceFrontAttachment.Name = "FaceFrontAttachment"
faceFrontAttachment.Position = Vector3.new(0, -0.24, -0.45)
faceFrontAttachment.Parent = handle
local mesh = Instance.new("SpecialMesh")
mesh.Name = "Mesh"
mesh.Scale = Vector3.new(1, 1.3, 1)
mesh.MeshId = "rbxassetid://1577360"
mesh.TextureId = "rbxassetid://1577349"
mesh.Parent = handle
humanoid:AddAccessory(clockworksShades)
BuildRigFromAttachments
Cette méthode assemble un arbre de Motor6D jointures pour le Humanoid . Motor6D jointures sont requises pour la lecture de Animations .
À partir du parent de l'humanoïde RootPart, cette méthode collecte tous les Attachments parents dans la partie actuelle dont le nom se termine par RigAttachment .Il recherche ensuite une pièce jointe correspondante dans le personnage qui partage le même nom que la pièce point d'attache.En utilisant ces deux attachments, une jointure Motor6D est générée en fonction des parties associées aux deux attachments et du CFrame des attachments.
Humanoid:BuildRigFromAttachments() également met à l'échelle le personnage et défini les couleurs du corps.
Retours
Échantillons de code
A Lua port of the Humanoid's BuildRigFromAttachments function, so that the recursive behavior of the function can be seen.
local function createJoint(jointName, att0, att1)
local part0, part1 = att0.Parent, att1.Parent
local newMotor = part1:FindFirstChild(jointName)
if not (newMotor and newMotor:IsA("Motor6D")) then
newMotor = Instance.new("Motor6D")
end
newMotor.Name = jointName
newMotor.Part0 = part0
newMotor.Part1 = part1
newMotor.C0 = att0.CFrame
newMotor.C1 = att1.CFrame
newMotor.Parent = part1
end
local function buildJointsFromAttachments(part, characterParts)
if not part then
return
end
-- first, loop thru all of the part's children to find attachments
for _, attachment in pairs(part:GetChildren()) do
if attachment:IsA("Attachment") then
-- only do joint build from "RigAttachments"
local attachmentName = attachment.Name
local findPos = attachmentName:find("RigAttachment")
if findPos then
-- also don't make double joints (there is the same named
-- rigattachment under two parts)
local jointName = attachmentName:sub(1, findPos - 1)
if not part:FindFirstChild(jointName) then
-- try to find other part with same rig attachment name
for _, characterPart in pairs(characterParts) do
if part ~= characterPart then
local matchingAttachment = characterPart:FindFirstChild(attachmentName)
if matchingAttachment and matchingAttachment:IsA("Attachment") then
createJoint(jointName, attachment, matchingAttachment)
buildJointsFromAttachments(characterPart, characterParts)
break
end
end
end
end
end
end
end
end
local function buildRigFromAttachments(humanoid)
local rootPart = humanoid.RootPart
assert(rootPart, "Humanoid has no HumanoidRootPart.")
local characterParts = {}
for _, descendant in ipairs(humanoid.Parent:GetDescendants()) do
if descendant:IsA("BasePart") then
table.insert(characterParts, descendant)
end
end
buildJointsFromAttachments(rootPart, characterParts)
end
local humanoid = script.Parent:WaitForChild("Humanoid")
buildRigFromAttachments(humanoid)
A script that generates an R15 character from scratch using a package's assetId.
local AssetService = game:GetService("AssetService")
local InsertService = game:GetService("InsertService")
local MarketplaceService = game:GetService("MarketplaceService")
local PACKAGE_ASSET_ID = 193700907 -- Circuit Breaker
local function addAttachment(part, name, position, orientation)
local attachment = Instance.new("Attachment")
attachment.Name = name
attachment.Parent = part
if position then
attachment.Position = position
end
if orientation then
attachment.Orientation = orientation
end
return attachment
end
local function createBaseCharacter()
local character = Instance.new("Model")
local humanoid = Instance.new("Humanoid")
humanoid.Parent = character
local rootPart = Instance.new("Part")
rootPart.Name = "HumanoidRootPart"
rootPart.Size = Vector3.new(2, 2, 1)
rootPart.Transparency = 1
rootPart.Parent = character
addAttachment(rootPart, "RootRigAttachment")
local head = Instance.new("Part")
head.Name = "Head"
head.Size = Vector3.new(2, 1, 1)
head.Parent = character
local headMesh = Instance.new("SpecialMesh")
headMesh.Scale = Vector3.new(1.25, 1.25, 1.25)
headMesh.MeshType = Enum.MeshType.Head
headMesh.Parent = head
local face = Instance.new("Decal")
face.Name = "face"
face.Texture = "rbxasset://textures/face.png"
face.Parent = head
addAttachment(head, "FaceCenterAttachment")
addAttachment(head, "FaceFrontAttachment", Vector3.new(0, 0, -0.6))
addAttachment(head, "HairAttachment", Vector3.new(0, 0.6, 0))
addAttachment(head, "HatAttachment", Vector3.new(0, 0.6, 0))
addAttachment(head, "NeckRigAttachment", Vector3.new(0, -0.5, 0))
return character, humanoid
end
local function createR15Package(packageAssetId)
local packageAssetInfo = MarketplaceService:GetProductInfo(packageAssetId)
local character, humanoid = createBaseCharacter()
character.Name = packageAssetInfo.Name
local assetIds = AssetService:GetAssetIdsForPackage(packageAssetId)
for _, assetId in pairs(assetIds) do
local limb = InsertService:LoadAsset(assetId)
local r15 = limb:FindFirstChild("R15")
if r15 then
for _, part in pairs(r15:GetChildren()) do
part.Parent = character
end
else
for _, child in pairs(limb:GetChildren()) do
child.Parent = character
end
end
end
humanoid:BuildRigFromAttachments()
return character
end
local r15Package = createR15Package(PACKAGE_ASSET_ID)
r15Package.Parent = workspace
ChangeState
Cette méthode fait en sorte que le Humanoid entre dans le Enum.HumanoidStateType donné, décrivant l'activité que le Humanoid fait actuellement.
Veuillez revoir la page Enum.HumanoidStateType pour plus d'informations sur les états spécifiques, car certains ont des noms peu intuitifs.Par exemple, Enum.HumanoidStateType.Running décrit un état où les jambes de l'humanoïde sont au sol, y compris lorsqu'elles sont immobiles.
En raison du comportement par défaut du Humanoid, certains états seront automatiquement modifiés lorsqu'ils sont configurer. Par exemple :
- Définir l'état à Enum.HumanoidStateType.Swimming lorsque l'humanoïde n'est pas dans l'eau provoquera son réglage automatique à Enum.HumanoidStateType.GettingUp .
- Comme il n'est pas utilisé, définir l'état à Enum.HumanoidStateType.PlatformStanding provoquera que l'état humanoïde soit automatiquement défini à Enum.HumanoidStateType.Running .
Notez que pour définir l'état en utilisant cette méthode, vous devez le faire à partir d'un et le client doit avoir la propriété réseau du ».Alternativement, vous pouvez appeler cette méthode à partir d'un côté serveur Script , mais le serveur doit avoir la propriété réseau du personnage du joueur.
Voir aussi Humanoid:SetStateEnabled() pour activer ou désactiver un état spécifique, et Humanoid:GetState() pour obtenir l'état humanoïde actuel.
Paramètres
Le Enum.HumanoidStateType que le Humanoid doit effectuer.
Retours
Échantillons de code
This code, when placed inside a LocalScript in StarterPlayer.StarterCharacterScripts, will allow the player's character to perform a double jump.
local UserInputService = game:GetService("UserInputService")
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local doubleJumpEnabled = false
humanoid.StateChanged:Connect(function(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not doubleJumpEnabled then
task.wait(0.2)
if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
doubleJumpEnabled = true
end
end
elseif newState == Enum.HumanoidStateType.Landed then
doubleJumpEnabled = false
end
end)
UserInputService.InputBegan:Connect(function(inputObject)
if inputObject.KeyCode == Enum.KeyCode.Space then
if doubleJumpEnabled then
if humanoid:GetState() ~= Enum.HumanoidStateType.Jumping then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
task.spawn(function()
doubleJumpEnabled = false
end)
end
end
end
end)
EquipTool
Cette méthode fait en sorte que le Humanoid équipe le donné Tool.
L'exemple ci-dessous provoquerait un Player pour équiper un outil dans Workspace nommé 'Outil' .
local Players = game:GetService("Players")local Workspace = game:GetService("Workspace")local player = Players:FindFirstChildOfClass("Player")if player and player.Character thenlocal humanoid = player.Character:FindFirstChildWhichIsA("Humanoid")if humanoid thenlocal tool = Workspace:FindFirstChild("Tool")if tool thenhumanoid:EquipTool(tool)endendend
Lorsque cette méthode est appelée, le Humanoid d'abord équipera automatiquement tout Tools qu'il a actuellement équipé.
Bien qu'ils soient équipés, Tools pour lesquels Tool.RequiresHandle est vrai ne fonctionnera pas s'ils n'ont pas de contrôleur, indépendamment du fait que cette méthode soit utilisée pour les équiper ou non.
Voir aussi :
- Pour déséquiper les outils, utilisez Humanoid:UnequipTools()
Paramètres
Retours
GetAccessories
Cette méthode renvoie un ensemble d'objets Accessory de l'humanoïde que le parent porte actuellement.Tous ces objets Accessory seront inclus, qu'ils soient attachés ou non.
Si le Humanoid n'a pas d'objets Accessory, un tableau vide sera renvoyé.
Voir aussi Humanoid:AddAccessory() pour attacher un Accessory à un parent d'un humanoïde.
Retours
Échantillons de code
This code sample will wait for accessories to fully load, print out how many there are, and then destroy them all.
local Players = game:GetService("Players")
local function onPlayerAddedAsync(player)
local connection = player.CharacterAppearanceLoaded:Connect(function(character)
-- All accessories have loaded at this point
local humanoid = character:FindFirstChildOfClass("Humanoid")
local numAccessories = #humanoid:GetAccessories()
print(("Destroying %d accessories for %s"):format(numAccessories, player.Name))
humanoid:RemoveAccessories()
end)
-- Make sure we disconnect our connection to the player after they leave
-- to allow the player to get garbage collected
player.AncestryChanged:Wait()
connection:Disconnect()
end
for _, player in Players:GetPlayers() do
task.spawn(onPlayerAddedAsync, player)
end
Players.PlayerAdded:Connect(onPlayerAddedAsync)
GetAppliedDescription
Cette méthode renvoie une copie du cache de l'humanoïde HumanoidDescription qui décrit son look actuel.Cela peut être utilisé pour déterminer rapidement l'apparence d'un personnage et pour attribuer son apparence à d'autres personnages en utilisant la méthode Humanoid:ApplyDescription().
Voir aussi
- Players:GetHumanoidDescriptionFromUserId() qui renvoie un HumanoidDescription décrivant l'avatar pour l'utilisateur passé.
- Players:GetHumanoidDescriptionFromOutfitId() qui renvoie un HumanoidDescription dont les paramètres sont initialisés pour correspondre à ceux de la ressource de tenue côté serveur passée.
- Player:LoadCharacterWithHumanoidDescription() qui génère un joueur avec le look du HumanoidDescription envoyé.
Retours
GetBodyPartR15
Cette méthode renvoie ce que Enum.BodyPartR15 un Part est, ou Enum.BodyPartR15.Unknown si la partie n'est pas une partie du corps R15.Cette méthode permet aux développeurs de récupérer des parties du corps du joueur indépendamment des noms réels des parties du corps, en retournant un ensemble.
Il peut être utilisé en conjonction avec Humanoid:ReplaceBodyPartR15().Par exemple, si la partie du corps d'un joueur touche quelque chose, cette fonction retournera une instance de partie.Les développeurs peuvent ensuite rechercher quelle partie du corps était, comme la tête ou le bras.Ensuite, en fonction de ce que cette partie était, les développeurs peuvent soit effectuer une action de jeu, soit remplacer cette partie par une autre partie - peut-être en montrant des dommages.
Cette méthode peut être utile pour les jeux où l'emplacement du coup est important.Par exemple, il peut être utilisé pour déterminer si un joueur est frappé dans la jambe et qu'il ralentit ensuite en fonction de la blessure.
Paramètres
La partie spécifiée est vérifiée pour voir si elle est une partie du corps R15.
Retours
Le type de corps R15 de la partie spécifiée ou inconnu si la partie n'est pas une partie du corps.
GetLimb
Cette méthode renvoie l'enumérité Enum.Limb qui est associée au Part donné. Elle fonctionne pour les rigs R15 et R6, par exemple :
-- Pour R15print(humanoid:GetLimb(character.LeftUpperLeg)) -- Enum.Limb.LeftLegprint(humanoid:GetLimb(character.LeftLowerLeg)) -- Enum.Limb.LeftLegprint(humanoid:GetLimb(character.LeftFoot)) -- Enum.Limb.LeftLeg-- Pour R6print(humanoid:GetLimb(character:FindFirstChild("Left Leg"))) -- Enum.Limb.LeftLeg
Notez que Humanoid:GetLimb() lancera une erreur si le parent de la partie n'est pas défini sur le parent de l'humanoïde.
Paramètres
Retours
Échantillons de code
Put this in a LocalScript. The output will vary based on if the humanoid is R6 or R15.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
for _, child in pairs(character:GetChildren()) do
local limb = humanoid:GetLimb(child)
if limb ~= Enum.Limb.Unknown then
print(child.Name .. " is part of limb " .. limb.Name)
end
end
GetState
Cette méthode renvoie le Enum.HumanoidStateType actuel de l'humanoïde, décrivant l'activité que le Humanoid fait actuellement, comme sauter ou nager.
Voir aussi Humanoid:SetStateEnabled() pour activer ou désactiver un état spécifique, et Humanoid:ChangeState() pour changer l'état humanoïde actuel.
Retours
L'actuel Enum.HumanoidStateType de la Humanoid.
Échantillons de code
This code, when placed inside a LocalScript in StarterPlayer.StarterCharacterScripts, will allow the player's character to perform a double jump.
local UserInputService = game:GetService("UserInputService")
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local doubleJumpEnabled = false
humanoid.StateChanged:Connect(function(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not doubleJumpEnabled then
task.wait(0.2)
if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
doubleJumpEnabled = true
end
end
elseif newState == Enum.HumanoidStateType.Landed then
doubleJumpEnabled = false
end
end)
UserInputService.InputBegan:Connect(function(inputObject)
if inputObject.KeyCode == Enum.KeyCode.Space then
if doubleJumpEnabled then
if humanoid:GetState() ~= Enum.HumanoidStateType.Jumping then
humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
task.spawn(function()
doubleJumpEnabled = false
end)
end
end
end
end)
GetStateEnabled
La méthode GetStateEnabled renvoie si un Enum.HumanoidStateType est activé pour le Humanoid.
L'état humanoïde décrit l'activité que l'humanoïde effectue actuellement.
Lorsqu'un particolare Enum.HumanoidStateType est désactivé, l'humanoïde ne peut jamais entrer dans cet état.Ceci est vrai indépendamment du fait que l'essai de changer l'état soit effectué en utilisant Humanoid:ChangeState() ou le code humanoïde interne de Roblox.
Voir aussi :
- Pour un événement qui se déclenche lorsqu'un état humanoïde est activé ou désactivé, voir Humanoid.StateEnabledChanged
- Pour activer ou désactiver un état Humanoid d'utilisation Humanoid:SetStateEnabled()
Paramètres
Le donné Enum.HumanoidStateType.
Retours
Si le donné Enum.HumanoidStateType est activé.
Échantillons de code
The code below sets the value of the humanoid jumping state to false using Humanoid:SetStateEnabled() and then retrieves and prints the value of this state (false) using Humanoid:GetStateEnabled().
local humanoid = script.Parent:WaitForChild("Humanoid")
-- Set state
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)
-- Get state
print(humanoid:GetStateEnabled(Enum.HumanoidStateType.Jumping)) -- false
Move
Cette méthode fait en sorte que la Humanoid marche dans la direction donnée Vector3.
Par défaut, la direction est en conditionsdu monde, mais si le paramètre relativeToCamera est true, la direction est relative à la CFrame du CurrentCamera.Comme la direction négative Z est considérée comme "vers l'avant" dans Roblox, le code suivant fera marcher l'humanoïde dans la direction du CurrentCamera.
humanoid:Move(Vector3.new(0, 0, -1), true)
Lorsque cette méthode est appelée, le Humanoid se déplacera jusqu'à ce que la méthode soit à nouveau appelée.Cependant, cette méthode sera remplacée dans le prochain cadre par le script de contrôle du personnage par défaut de Roblox.Cela peut être évité en appelant cette fonction à chaque cadre en utilisant RunService:BindToRenderStep() (voir exemple), ou en écrasant les scripts de contrôle dans StarterPlayerScripts .
Cette méthode peut être appelée sur le serveur, mais cela ne devrait se faire que lorsque le serveur a la propriété réseau de l'assemblage de l'humanoïde.
Voir aussi qui fait une promenade à un point, et qui appelle effectivement cette fonction.
Paramètres
La direction dans laquelle marcher.
Définir à true si le paramètre moveDirection doit être pris comme relatif au CurrentCamera.
Retours
Échantillons de code
This code sample uses the Humanoid:Move() function to make the player's Character walk in the direction of the Camera. RunService:BindToRenderStep() is required here as the default control scripts will overwrite the player's movement every frame.
To run this sample, place it inside a LocalScript parented to StarterCharacterScripts.
local RunService = game:GetService("RunService")
local Players = game:GetService("Players")
local player = Players.LocalPlayer
RunService:BindToRenderStep("move", Enum.RenderPriority.Character.Value + 1, function()
if player.Character then
local humanoid = player.Character:FindFirstChild("Humanoid")
if humanoid then
humanoid:Move(Vector3.new(0, 0, -1), true)
end
end
end)
MoveTo
Cette méthode cause le Humanoid à essayer de se rendre à l'emplacement donné en définissant les propriétés Humanoid.WalkToPoint et Humanoid.WalkToPart.
Les paramètres de localisation et de partie correspondent à ce qui sera défini comme et .
Si le paramètre partie est spécifié, le Humanoid tentera toujours de marcher jusqu'au point.Cependant, si la partie se déplace, le point Humanoid se déplacera pour être à la même position par rapport à la partie .Si le paramètre partie n'est pas spécifié, alors la position à laquelle la Humanoid marche ne changera pas.
L'état de atteindre l'objectif d'un humanoïde expirera après 8 secondes s'il ne parvient pas à son objectif.Cela est fait pour que les PNJ ne soient pas coincés en attendant que Humanoid.MoveToFinished lancer.Si vous ne voulez pas que cela se produise, vous devez appeler à plusieurs reprises MoveTo afin que l'expiration se réinitialise à nouveau.
MoveTo() se termine si l'une des conditions suivantes s'applique :
Le personnage arrive à sa destination. Il y a un seuil ~1 de studs pour tenir compte de différentes vitesses et fréquences de cadence des humanoïdes.
Le personnage est bloqué et l'horloge de huit secondes expire.
La valeur de either Humanoid.WalkToPoint ou Humanoid.WalkToPart change.
Un script appelle Humanoid:Move() avec un nouveau paramètre moveDirection.
Paramètres
La position pour définir Humanoid.WalkToPoint à.
Le BasePart pour définir Humanoid.WalkToPart .
Retours
Échantillons de code
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
local function moveTo(humanoid, targetPoint, andThen)
local targetReached = false
-- listen for the humanoid reaching its target
local connection
connection = humanoid.MoveToFinished:Connect(function(reached)
targetReached = true
connection:Disconnect()
connection = nil
if andThen then
andThen(reached)
end
end)
-- start walking
humanoid:MoveTo(targetPoint)
-- execute on a new thread so as to not yield function
task.spawn(function()
while not targetReached do
-- does the humanoid still exist?
if not (humanoid and humanoid.Parent) then
break
end
-- has the target changed?
if humanoid.WalkToPoint ~= targetPoint then
break
end
-- refresh the timeout
humanoid:MoveTo(targetPoint)
task.wait(6)
end
-- disconnect the connection if it is still connected
if connection then
connection:Disconnect()
connection = nil
end
end)
end
local function andThen(reached)
print((reached and "Destination reached!") or "Failed to reach destination!")
end
moveTo(script.Parent:WaitForChild("Humanoid"), Vector3.new(50, 0, 50), andThen)
RemoveAccessories
Cette méthode supprime tous les objets Accessory portés par le parent de l'humanoïde. Pour le joueur Characters, cela supprimera tous les chapeaux et autres accessoires.
Cette méthode supprime l'objet Accessory en appelant Instance:Destroy() dessus, ce qui signifie que le Parent des accessoires est réglé sur nil et verrouillé.
Voir aussi pour attacher un , et pour obtenir tous les objets appartenant à un .
Retours
Échantillons de code
This code sample will wait for accessories to fully load, print out how many there are, and then destroy them all.
local Players = game:GetService("Players")
local function onPlayerAddedAsync(player)
local connection = player.CharacterAppearanceLoaded:Connect(function(character)
-- All accessories have loaded at this point
local humanoid = character:FindFirstChildOfClass("Humanoid")
local numAccessories = #humanoid:GetAccessories()
print(("Destroying %d accessories for %s"):format(numAccessories, player.Name))
humanoid:RemoveAccessories()
end)
-- Make sure we disconnect our connection to the player after they leave
-- to allow the player to get garbage collected
player.AncestryChanged:Wait()
connection:Disconnect()
end
for _, player in Players:GetPlayers() do
task.spawn(onPlayerAddedAsync, player)
end
Players.PlayerAdded:Connect(onPlayerAddedAsync)
ReplaceBodyPartR15
Remplace dynamiquement une partie de membre R15/Rthro dans un humanoïde par une partie différente. La partie est automatiquement redimensionnée comme d'habitude.
Cette méthode est utile pour modifier des personnages pendant le jeu ou pour construire des personnages à partir d'un plateformede base.La méthode associée GetBodyPartR15 peut être utile lors de l'utilisation de cette méthode.
Le nom de la partie transmise doit correspondre au nom du BodyPartR15 Enum transmis.
Paramètres
La partie du corps à remplacer. Enum.BodyPartR15.Unknown échouera.
Le Class.Part``Class.Instance qui sera parenté au personnage.
Retours
SetStateEnabled
Cette méthode détermine si un donné Enum.HumanoidStateType est activé pour le Humanoid.Lorsqu'un particolare Enum.HumanoidStateType est désactivé, le Humanoid ne peut jamais entrer dans cet état.Ceci est vrai indépendamment du fait que l'essai de changer l'état soit effectué en utilisant Humanoid:ChangeState() ou le code interne Roblox Humanoid.
Notez que l'utilisation de SetStateEnabled() sur le serveur ne réplique pas le changement au client, ni vice versa.
Paramètres
Le Enum.HumanoidStateType à activer ou désactiver.
true si state doit être activé, false si state doit être désactivé.
Retours
Échantillons de code
The following sample will require a one second cooldown after a Humanoid has landed before it is able to jump again.
To try this sample, place it inside a LocalScript in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
local character = script.Parent
local JUMP_DEBOUNCE = 1
local humanoid = character:WaitForChild("Humanoid")
local isJumping = false
humanoid.StateChanged:Connect(function(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not isJumping then
isJumping = true
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)
end
elseif newState == Enum.HumanoidStateType.Landed then
if isJumping then
isJumping = false
task.wait(JUMP_DEBOUNCE)
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, true)
end
end
end)
TakeDamage
Cette méthode réduit le du par le montant donné si elle n'est pas protégée par un >
Cette méthode accepte des valeurs négatives pour le paramètre quantité.Cela augmentera la Humanoid.Health de l'humanoïde.Cependant, cela n'aura d'effet que si aucun ForceField n'est présent.
Comment les champs de force protègent-ils contre les dommages pris
Un Humanoid est considéré comme protégé par un ForceField si un ForceField répond à l'une des conditions suivantes :
Pour faire des dommages à un Humanoid indépendamment de tout ForceFields présent, définissez Humanoid.Health directement.
Pour plus d'informations sur la façon dont ForceFields protéger Humanoids voir la page ForceField.
Paramètres
Les dommages, ou la somme à déduire de la Humanoid.Health.
Retours
Échantillons de code
This code, put in a LocalScript, would make the local player take 99 damage only if a ForceField wasn't present.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
humanoid:TakeDamage(99)
UnequipTools
Cette méthode déséquipe n'importe quel Tool actuellement équipé par le Humanoid
Le déséquipé Tool sera parenté au Backpack du Player associé au Humanoid .
Si aucun Tool n'est équipé, cette méthode ne fera rien.
Bien que Tools puisse être équipé par des PNJ (personnages non joueurs), cette méthode ne fonctionne que sur Humanoids avec un correspondant Player.C'est parce qu'un objet Backpack est requis pour parenter l'équipement non équipé Tool.
Voir aussi :
- Pour équiper au lieu de cela un Tool, utilisez Humanoid:EquipTool()
Retours
Échantillons de code
The following sample will bind the U key to unequip any Tool|Tools the Player currently has equipped.
To use this sample, place it inside a LocalScript within StarterPlayerScripts|StarterPlayer.StarterPlayerScripts.
local Players = game:GetService("Players")
local ContextActionService = game:GetService("ContextActionService")
local player = Players.LocalPlayer
ContextActionService:BindAction("unequipTools", function(_, userInputState)
if userInputState == Enum.UserInputState.Begin then
if player.Character then
local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
if humanoid then
humanoid:UnequipTools()
end
end
end
end, false, Enum.KeyCode.U)
ApplyDescription
Cette méthode de reddition fait correspondre le regard du personnage à celui du passe dans HumanoidDescription.Une copie du passe HumanoidDescription est mise en cache comme le HumanoidDescription pour le Humanoid .
Cette méthode est optimisée en faisant l'hypothèse que seule cette méthode est utilisée pour modifier l'apparence du personnage, et aucun changement n'est apporté par d'autres moyens entre les appels.Si des modifications sont apportées au personnage entre les appels, cette méthode peut ne pas faire en sorte que le personnage reflète avec précision ce qui a été passé en HumanoidDescription.Si vous voulez utiliser cette méthode en conjonction avec d'autres moyens de mettre à jour le personnage, Humanoid:ApplyDescriptionReset() assurera toujours que le personnage reflète le HumanoidDescription transmis.
Voir aussi
- Humanoid:GetAppliedDescription() qui renvoie le HumanoidDescription actuellement appliqué à l'humanoïde.
- Players:GetHumanoidDescriptionFromUserId() qui renvoie un HumanoidDescription décrivant l'avatar pour l'utilisateur passé.
- Players:GetHumanoidDescriptionFromOutfitId() qui renvoie un HumanoidDescription dont les paramètres sont initialisés pour correspondre à ceux de la ressource de tenue côté serveur passée.
- Player:LoadCharacterWithHumanoidDescription() qui génère un joueur avec le look du HumanoidDescription envoyé.
Paramètres
L'instance HumanoidDescription que vous voulez définir pour que le personnage correspondre.
Retours
ApplyDescriptionReset
Cette méthode de reddition fait correspondre le regard du personnage à celui du HumanoidDescription envoyé, même après des modifications externes.Une copie du passe HumanoidDescription est mise en cache comme le HumanoidDescription pour le Humanoid .
Cette méthode garantira toujours que le personnage reflète ce qui a été passé dans HumanoidDescription, même si des modifications ont été apportées au personnage n'utilisant pas le système HumanoidDescription (par exemple, n'utilisant pas ApplyDescriptionReset() ou ApplyDescription() ).Cela est en contraste avec ApplyDescription() qui est optimisé et peut appliquer de manière incorrecte un HumanoidDescription si le caractère a été modifié par des moyens autres que par le biais du système HumanoidDescription.
Paramètres
L'instance HumanoidDescription que vous voulez définir pour que le personnage correspondre.
Retours
PlayEmote
Si l'émote ne peut pas être jouée car l'émoteName n'est pas trouvée dans la description humanoïde, cette méthode renvoie une erreur.La méthode renverra true pour indiquer que l'émote a été jouée avec succès.
Paramètres
nom de l'émote à jouer.
Retours
joué avec succès.
Évènements
Climbing
S'enflamme lorsque la vitesse à laquelle un Humanoid monte change.
Humanoids peut escalader des échelles faites de Parts ou TrussParts.
Humanoids monte à 70% de leur Humanoid.WalkSpeed .
Cet événement ne se déclenchera pas toujours à une vitesse de 0 lorsque les Humanoid arrêteront de monter.
Voir aussi :
- Pour la natation et la course, voir les événements Humanoid.Swimming et Humanoid.Running
- Vous pouvez également détecter quand un Humanoid monte en utilisant l'événement Humanoid.StateChanged
- Vous pouvez désactiver l'escalade en utilisant la fonction Humanoid:SetStateEnabled()
Paramètres
Échantillons de code
local Players = game:GetService("Players")
local function onCharacterClimbing(character, speed)
print(character.Name, "is climbing at a speed of", speed, "studs / second.")
end
local function onCharacterAdded(character)
character.Humanoid.Climbing:Connect(function(speed)
onCharacterClimbing(character, speed)
end)
end
local function onPlayerAdded(player)
player.CharacterAdded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
Died
Cet événement se déclenche lorsque le Humanoid meurt, généralement lorsque Humanoid.Health atteint 0.Cela pourrait être causé par le fait de débrancher leur tête de leur Humanoid.Torso ou de définir directement la propriété de santé.
Cet événement ne se déclenche que si le Humanoid est un descendant du Workspace . Si le Dead``Enum.HumanoidStateType est désactivé, il ne se lancerpas.
Échantillons de code
The code below would print the player's name, followed by "has died!", whenever a player dies. For example, if the player was named "Shedletsky", "Shedletsky has died!" would be printed to the output when they died.
local Players = game:GetService("Players")
local function onPlayerAdded(player)
local function onCharacterAdded(character)
local humanoid = character:WaitForChild("Humanoid")
local function onDied()
print(player.Name, "has died!")
end
humanoid.Died:Connect(onDied)
end
player.CharacterAdded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
FallingDown
L'événement FallingDown se déclenche lorsque le Humanoid entre et quitte le FallingDown``Enum.HumanoidStateType .
Le Humanoid entrera dans l'état GettingUp 3 secondes après que l'état FallingDown soit activé.Lorsque cela se produit, cet événement se déclenchera avec une valeur active de faux et Humanoid.GettingUp se déclenchera avec une valeur active de vrai .
Paramètres
FreeFalling
Cet événement se déclenche lorsque le Humanoid entre ou quitte le Freefall``Enum.HumanoidStateType .
Le paramètre actif représente si le > entre ou quitte l'état >.
Bien que l'état finisse généralement lorsque l'état atteint le sol, cet événement peut se déclencher avec actif égal à faux si l'état est modifié pendant que l'état tombe.Pour cette raison, vous devez utiliser Humanoid.StateChanged et écouter l'état Landed lorsqu'un Humanoid est atterri.
Paramètres
GettingUp
Cet événement se déclenche lorsque le Humanoid entre ou quitte l'état Enum.HumanoidStateType.GettingUp, un état de transition qui est activé peu après que le Humanoid entre dans l'état FallingDown (3 secondes) ou Ragdoll (1 seconde).
Lorsqu'une Humanoid tentera de se relever, cet événement se déclenchera d'abord avec un paramètre active de true avant de tirer à nouveau avec un paramètre active de false .
Pour forcer un Humanoid à tomber, utilisez la fonction Humanoid:ChangeState() avec Enum.HumanoidStateType.FallingDown.
Paramètres
HealthChanged
Cet événement se déclenche lorsque les modifications de Humanoid.Health changent.Cependant, il ne tirera pas si la santé augmente à partir d'une valeur égale ou supérieure à la valeur Humanoid.MaxHealth.
Lorsque Humanoid.Health atteint zéro, le Humanoid mourra et l'événement Humanoid.Died se lancer. Cet événement se déclenchera avec une valeur de zéro.
Paramètres
La nouvelle valeur de Humanoid.Health.
Échantillons de code
The following example determines the change in health, printing it to the output. It will only work in a LocalScript.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local function onCharacterAdded(character)
local humanoid = character:WaitForChild("Humanoid")
local currentHealth = humanoid.Health
local function onHealthChanged(health)
local change = math.abs(currentHealth - health)
print("The humanoid's health", (currentHealth > health and "decreased by" or "increased by"), change)
currentHealth = health
end
humanoid.HealthChanged:Connect(onHealthChanged)
end
player.CharacterAdded:Connect(onCharacterAdded)
This code sample allows you to create a simple color-changing health bar using two nested Frames. Paste this into a LocalScript on the inner frame.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
-- Paste script into a LocalScript that is
-- parented to a Frame within a Frame
local frame = script.Parent
local container = frame.Parent
container.BackgroundColor3 = Color3.new(0, 0, 0) -- black
-- This function is called when the humanoid's health changes
local function onHealthChanged()
local human = player.Character.Humanoid
local percent = human.Health / human.MaxHealth
-- Change the size of the inner bar
frame.Size = UDim2.new(percent, 0, 1, 0)
-- Change the color of the health bar
if percent < 0.1 then
frame.BackgroundColor3 = Color3.new(1, 0, 0) -- black
elseif percent < 0.4 then
frame.BackgroundColor3 = Color3.new(1, 1, 0) -- yellow
else
frame.BackgroundColor3 = Color3.new(0, 1, 0) -- green
end
end
-- This function runs is called the player spawns in
local function onCharacterAdded(character)
local human = character:WaitForChild("Humanoid")
-- Pattern: update once now, then any time the health changes
human.HealthChanged:Connect(onHealthChanged)
onHealthChanged()
end
-- Connect our spawn listener; call it if already spawned
player.CharacterAdded:Connect(onCharacterAdded)
if player.Character then
onCharacterAdded(player.Character)
end
Jumping
Cet événement se déclenche lorsque le Humanoid entre et quitte le Jumping``Enum.HumanoidStateType .
Lorsqu'un saut Humanoid apparaît, cet événement se déclenche avec un paramètre active de true avant de tirer à nouveau avec un paramètre active de false peu de temps après.Ce deuxième tir ne correspond pas à un atterrissage Class.Humanoid``Landed``Enum.HumanoidStateType en utilisant Humanoid.StateChanged .
Vous pouvez désactiver le saut en utilisant la fonction Humanoid:SetStateEnabled().
Paramètres
MoveToFinished
Cet événement se déclenche lorsque le Humanoid finit de marcher vers un objectif déclaré par les propriétés Humanoid.WalkToPoint et Humanoid.WalkToPart.
Les propriétés Humanoid.WalkToPoint et Humanoid.WalkToPart peuvent être définies individuellement ou en utilisant la fonction Humanoid:MoveTo().
Si le Humanoid atteint son objectif dans les 8 secondes, cet événement reviendra avec atteint comme vrai.Si l'objectif n'est pas atteint dans les 8 secondes, le Humanoid cessera de marcher et le atteint sera faux.Ce délai d'expiration peut être réinitialisé en appelant à nouveau Humanoid:MoveTo() dans la période de temps limite.
Paramètres
Échantillons de code
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
local function moveTo(humanoid, targetPoint, andThen)
local targetReached = false
-- listen for the humanoid reaching its target
local connection
connection = humanoid.MoveToFinished:Connect(function(reached)
targetReached = true
connection:Disconnect()
connection = nil
if andThen then
andThen(reached)
end
end)
-- start walking
humanoid:MoveTo(targetPoint)
-- execute on a new thread so as to not yield function
task.spawn(function()
while not targetReached do
-- does the humanoid still exist?
if not (humanoid and humanoid.Parent) then
break
end
-- has the target changed?
if humanoid.WalkToPoint ~= targetPoint then
break
end
-- refresh the timeout
humanoid:MoveTo(targetPoint)
task.wait(6)
end
-- disconnect the connection if it is still connected
if connection then
connection:Disconnect()
connection = nil
end
end)
end
local function andThen(reached)
print((reached and "Destination reached!") or "Failed to reach destination!")
end
moveTo(script.Parent:WaitForChild("Humanoid"), Vector3.new(50, 0, 50), andThen)
PlatformStanding
Cet événement se déclenche lorsque le Humanoid entre ou quitte le PlatformStanding``Enum.HumanoidStateType .
Pendant que le Humanoid est dans l'état PlatformStanding, la propriété Humanoid.PlatformStand sera vraie.
Bien que Humanoid.PlatformStand soit réglé sur vrai, le Humanoid ne pourra pas se mouvement. Pour plus d'informations, voir la page pour Humanoid.PlatformStand .
Le stand de plate-forme Enum.HumanoidStateType a été associé à la partie désactivée Platform maintenant. Malgré cela, il peut toujours être utilisé par les développeurs.
Paramètres
Ragdoll
Cet événement se déclenche lorsque le Humanoid entre ou quitte le Ragdoll``Enum.HumanoidStateType .
Le paramètre active aura la valeur true ou false pour indiquer l'entrée ou la sortie.
Utilisez Humanoid:SetStateEnabled() pour désactiver l'état GettingUp pour rester dans l'état Ragdoll.
Voir aussi :
- Humanoid.FallingDown pour l'événement Humanoid connecté avec l'état FallingDown, qui se comporte de manière similaire à Ragdoll
Paramètres
Running
Cet événement se déclenche lorsque la vitesse à laquelle un Humanoid est en cours de modification change.
Pendant l'exécution de Humanoids couverture, en moyenne, leur Humanoid.WalkSpeed en studs par seconde.
Lorsque le Humanoid arrête d'exécuter cet événement, il se déclenchera à une vitesse de 0.
Voir aussi :
- Pour la natation et l'escalade, voir les événements Humanoid.Swimming et Humanoid.Climbing
- Vous pouvez également détecter quand un Humanoid est en cours d'exécution en utilisant l'événement Humanoid.StateChanged
Paramètres
Échantillons de code
Demonstrates connecting to the Humanoid.Running event. The event is connected to every player's humanoid that joins.
The function connected will print whether or not the humanoid is running based on the speed.
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
local character = localPlayer.Character or localPlayer.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local function onRunning(speed: number)
if speed > 0 then
print(`{localPlayer.Name} is running`)
else
print(`{localPlayer.Name} has stopped`)
end
end
humanoid.Running:Connect(function(speed: number)
onRunning(speed)
end)
Seated
Cet événement se déclenche lorsqu'un Humanoid est assis ou se lève de un Seat ou VehicleSeat .
Lorsqu'un personnage entre en contact avec un siège, il est attaché au siège et une animation de sieste se joue.Pour plus d'informations à ce sujet, voir la page Seat .
- Si le personnage est assis, le paramètre active sera vrai et currentSeatPart sera la place sur laquelle il est actuellement assis.
- Si le personnage se lève d'un siège, le paramètre sera faux et sera ».
Voir aussi :
- Humanoid.Sit , ce qui indique si un humanoïde est actuellement assis
- Humanoid.SeatPart , qui indique la place sur laquelle un humanoïde est actuellement assis, si nécessaire.
Paramètres
Échantillons de code
This code sample demonstrates when the local player's Character sits down or stands up. It should be placed inside a LocalScript within StarterCharacterScripts in order to run when the player's character spawns in.
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local function onSeated(isSeated, seat)
if isSeated then
print("I'm now sitting on: " .. seat.Name .. "!")
else
print("I'm not sitting on anything")
end
end
humanoid.Seated:Connect(onSeated)
StateChanged
Cet événement se déclenche lorsque l'état du Humanoid est modifié.
Comme il n'y a pas d'état humanoïde « inactif », vous devez plutôt utiliser l'événement Humanoid.Running ou écouter la partie RootPart de la Velocity pour déterminer quand le Humanoid est immobile.
Voir aussi
- Humanoid:GetState() et Humanoid:ChangeState() pour obtenir et définir l'état.
- Humanoid:SetStateEnabled() pour activer et désactiver des états spécifiques.
Paramètres
Le taperd'état précédent de l'humanoïde.
Le taperd'état actuel de l'humanoïde.
Échantillons de code
Emits particles from the local player's Player.Character when they jump. To try this code sample, place it inside a LocalScript parented to StarterCharacterScripts.
local character = script.Parent
local primaryPart = character.PrimaryPart
-- create particles
local particles = Instance.new("ParticleEmitter")
particles.Size = NumberSequence.new(1)
particles.Transparency = NumberSequence.new(0, 1)
particles.Acceleration = Vector3.new(0, -10, 0)
particles.Lifetime = NumberRange.new(1)
particles.Rate = 20
particles.EmissionDirection = Enum.NormalId.Back
particles.Enabled = false
particles.Parent = primaryPart
local humanoid = character:WaitForChild("Humanoid")
local isJumping = false
-- listen to humanoid state
local function onStateChanged(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not isJumping then
isJumping = true
particles.Enabled = true
end
elseif newState == Enum.HumanoidStateType.Landed then
if isJumping then
isJumping = false
particles.Enabled = false
end
end
end
humanoid.StateChanged:Connect(onStateChanged)
The following sample will require a one second cooldown after a Humanoid has landed before it is able to jump again.
To try this sample, place it inside a LocalScript in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
local character = script.Parent
local JUMP_DEBOUNCE = 1
local humanoid = character:WaitForChild("Humanoid")
local isJumping = false
humanoid.StateChanged:Connect(function(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not isJumping then
isJumping = true
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)
end
elseif newState == Enum.HumanoidStateType.Landed then
if isJumping then
isJumping = false
task.wait(JUMP_DEBOUNCE)
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, true)
end
end
end)
StateEnabledChanged
L'événement StateEnableChanged se déclenche lorsque Humanoid:SetStateEnabled() est appelé sur le Humanoid.
Les paramètres incluent le Enum.HumanoidStateType en question ainsi qu'un bool indiquant si cet état est désormais activé.
Voir aussi :
- Pour trouver si un état est actuellement activé, utilisez Humanoid:GetStateEnabled()
- Pour écouter les modifications d'état Humanoid utilisez Humanoid.StateChanged
Paramètres
Le Enum.HumanoidStateType pour lequel l'état activé a été modifié.
Vrai si l'état est désormais activé.
Échantillons de code
When a humanoid state changes for the Players.LocalPlayer, the code below prints whether the state has been enabled or disabled.
This code should work as expected when placed in a LocalScript.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local function onStateEnabledChanged(state, enabled)
if enabled then
print(state.Name .. " has been enabled")
else
print(state.Name .. " has been disabled")
end
end
humanoid.StateEnabledChanged:Connect(onStateEnabledChanged)
Strafing
Cet événement ne se déclenche pas lorsque le Humanoid est détourné et ne devrait pas être utilisé par les développeurs
Cet événement se déclenche lorsque le Humanoid entre ou quitte le StrafingNoPhysics``Enum.HumanoidStateType .
Lorsque le Humanoid entre dans l'état StrafingNoPhysics, cet événement se déclenchera avec un paramètre actif de vrai.L'événement se déclenchera à nouveau avec actif égal à faux lorsque le quittera l'état .
Cet événement est associé à l'état et ne se déclenche pas lorsque le se déplace perpendiculairement à la direction vers laquelle il est dirigé.Cet état est actuellement inutilisé, s'il est défini en utilisant Humanoid:ChangeState() l'état reviendra à RunningNoPhysics .
Paramètres
Swimming
Cet événement se déclenche lorsque la vitesse à laquelle un Humanoid nage dans l'eau change en Terrain.
Humanoids nager à 87,5 % de leur Humanoid.WalkSpeed .
Cet événement ne se déclenchera pas toujours à une vitesse de 0 lorsque le Humanoid arrêtera de nager.
Voir aussi :
- Pour la course et l'escalade, voir les événements Humanoid.Running et Humanoid.Climbing
- Vous pouvez également détecter quand un Humanoid nage en utilisant l'événement Humanoid.StateChanged
- Vous pouvez désactiver la natation en utilisant la fonction Humanoid:SetStateEnabled()
Paramètres
Touched
Cet événement se déclenche lorsque l'une des membres d'un humanoïde entre en contact avec un autre BasePart.Le BasePart que la limbe touche, ainsi que la limbe elle-même, est donné.
Cet événement ne se déclenchera pas lorsque des membres appartenant à la Humanoid entreront en contact avec eux-mêmes.
Des alternatives
Bien que l'événement Humanoid.Touched soit utile, vous devez envisager s'il existe des alternatives qui répondent mieux à vos besoins.
- Dans la plupart des cas, il est conseillé de connecter un événement d'intérêt au lieu de cela, car l'événement se déclenchera constamment lorsque l'humanoïde se déplace.Par exemple, dans un jeu de dodgeball, il serait plus pratique de connecter un événement Touched pour les balles plutôt que d'utiliser Humanoid.Touched .
- Lorsque vous essayez de déterminer quand le Humanoid a atterri sur le sol, l'événement Humanoid.StateChanged est plus approprié.Alternativement, vous pouvez vérifier Humanoid.FloorMaterial pour voir si l'humanoïde se tient sur un matériau non aérien.
Notations
- La connexion à cet événement provoquera la création d'un TouchTransmitter dans chaque membre.
- Il n'existe actuellement pas d'équivalent de BasePart.TouchEnded pour Humanoids.
Paramètres
Échantillons de code
When placed inside a Player.Character model this code will give a player the 'Midas touch'. Everything their character touches will change to gold.
When the Humanoid dies, this change is undone and the golden BasePart|BaseParts are returned to their original state.
To test this out, place this code inside a Script and place it in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local partInfo = {}
local debounce = false
local function onHumanoidTouched(hit, _limb)
if debounce then
return
end
if not hit.CanCollide or hit.Transparency ~= 0 then
return
end
if not partInfo[hit] then
partInfo[hit] = {
BrickColor = hit.BrickColor,
Material = hit.Material,
}
hit.BrickColor = BrickColor.new("Gold")
hit.Material = Enum.Material.Ice
debounce = true
task.wait(0.2)
debounce = false
end
end
local touchedConnection = humanoid.Touched:Connect(onHumanoidTouched)
local function onHumanoidDied()
if touchedConnection then
touchedConnection:Disconnect()
end
-- undo all of the gold
for part, info in pairs(partInfo) do
if part and part.Parent then
part.BrickColor = info.BrickColor
part.Material = info.Material
end
end
end
humanoid.Died:Connect(onHumanoidDied)