Humanoid

AutoJumpEnabled détermine si oui ou non le Humanoid essaie de sauter automatiquement par-dessus un obstacle qu'il traverse.

Actuellement, cette propriété ne fonctionne que lorsque les conditions suivantes sont vérées :

• Le modèle de caractère du Humanoid 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.

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()

La propriété AutoRotate décrit si oui ou non le Humanoid tournera automatiquement pour faire face dans la direction dans laquelle ils se déplacent. Lorsqu'il est réglé sur vrai, le modèle de caractère se tournera progressivement pour faire face à leur direction de déplacement à mesure que le Humanoid se promène. Lorsqu'il est réglé sur faux, le modèle de caractère restera fixé dans sa rotation actuelle, à moins qu'une force de rotation soit appliquée au Rotation de la partie racine du humanoid.

Si le modèle de personnage se trouve être le personnage d'un joueur, alors le comportement de la rotation de l'humanoïde est influencé par la propriété Type de rotation de l'UserGameSettings.

Lorsque la propriété AutoRotate est réglée sur vrai, la propriété RotateType a les effets suivants sur la rotation de l'humanoïde :

<tbody>
  <tr>
    <td>Mouvement relatif</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 vue subjective, ou il est en mode mode de changement de vitesse.</td>
  </tr>
</tbody>

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

Le Humanoid a six valeurs de mise à l'échelle des enfants, y compris BodyDepthScale, BodyHeightScale », BodyProportionScale », 1> BodyTypeScale », 4> HeadScale ». Changer la valeur de l'un de ces facteurs provoque que les parties et accesso

Détermine si les articulations du humanoid se brisent lorsque vous êtes dans l'état Enum.HumanoidStateType.Dead. Par défaut, les valeurs sont réglées sur true.

La propriété CameraOffset spécifie un décalage à la position de l'objet de la caméra lorsque son Camera.CameraSubject est défini sur cette position Humanoid.

L'Offset est appliqué dans l'espace objet, relativement à l'orientation du Humanoid's HumanoidRootPart . Par exemple, une valeur Vector3 d'unOffset de (0, 10, 0) déplace la caméra du joueur de 10 studs au-dessus du joueur's humanoid.

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)

La propriété DisplayDistanceType contrôle le comportement de distance du nom et de la santé du humanoïde. Cette propriété est définie en utilisant le Enum.HumanoidDisplayDistanceType enum avec trois valeurs disponibles, chacune avec leur propre ensemble de règles :

• Lorsque vous avez défini sur Viewer, le humanoid voit le nom/santé des autres humanoïdes dans la portée de son propre NameDisplayDistance et HealthDisplayDistance .
• Lorsque vous avez défini sur Subject, le humanoid prend le contrôle complet sur son propre nom et sa santé affichée à travers ses valeurs NameDisplayDistance et NameDisplayDistance.
• Lorsque vous avez défini sur None, la barre de nom et la santé du humanoid ne s'affichent pas sous aucune circonstance.

Voir Nom du personnage/Affichage de la santé pour un guide en détail sur le contrôle de l'apparence des noms de personnages et des barres de santé.

local humanoid = script.Parent

humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.Viewer
humanoid.HealthDisplayDistance = 0
humanoid.NameDisplayDistance = 100

DisplayName est une propriété qui détermine la façon dont le nom du humanoid est affiché lorsqu'il est visible. Par défaut, un nouveau humanoid aura la valeur d'une chaîne vide. Si DisplayName est une chaîne vide, la façon dont le nom du humanoid sera affiché sera la valeur par défaut du nom de l'父.

Chargement du personnage du joueur

Lorsque les joueurs chargent leur personnage, soit automatiquement soit par l'utilisation de LoadCharacter(), le Humanoid qui est créé par le moteur aura son DisplayName propriété de DisplayName à la propriété du joueur.

StarterCharacter et StarterHumanoid

Lorsqu'un Humanoid nommé StarterHumanoid est associé à StarterHumanoid, ou

Ceci est une propriété de lecture unique qui décrit le Enum.Material sur lequel se trouve actuellement le Humanoid. Il fonctionne avec les deux types de voxels Parts et 1> Class.Terrain1>.

L'exemple de code ci-dessous montre comment écouter quand cette propriété change en utilisant Object:GetPropertyChangedSignal() . Lorsque le matériau sur lequel se trouve le humanoid change, il imprimera un message indiquant que le nouveau matériau est sur lequel il est basé.

local Humanoid = route.to.humanoid

Humanoid:GetPropertyChangedSignal("FloorMaterial"):Connect(function()
	print("New value for FloorMaterial: " .. tostring(Humanoid.FloorMaterial))
end)

Grotte

• Lorsque la valeur Humanoid n'est pas sur un sol, la valeur de cette propriété sera réglée sur Air.

  • Ceci se produit car les propriétés de ce type ne peuvent pas avoir de valeur vide.
  • Ceci peut causer une certaines modifications si un matériau est réglé sur Air, bien que dans la pratique, les parties ne sont pas censées utiliser ce matériau en premier emplacement.
• Le modèle de caractère du Humanoid doit être capable de se heurter au sol, ou il ne sera pas détecté.

  • Vous ne pouvez pas tester si le Humanoid nage avec cette propriété. Vous devriez plutôt utiliser sa fonction Humanoid:GetState().

Cette propriété représente la santé actuelle du Humanoid . La valeur est restreinte à la tranche entre 0 et MaxHealth . Si le humanoid est mort, cette propriété est continuellement réglée sur 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é passif est automatiquement inséré dans les humanoides. Cela cause les personnages non morts de générer 1 % de MaxHealth chaque seconde. Pour désactiver ce comportement de régénération, ajoutez un script vide nommé Script nommé Santé à 1> Class.StarterCharacterScript

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 du HealthDisplayDistance et du 1> Class.Humanoid.HealthDisplayType

Voir Nom du personnage/Affichage de la santé pour un guide en détail 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, le Humanoid passe automatiquement au Enum.HumanoidStateType.Dead état. Dans cet état, Health est verrouillé à 0 ; cependant, il n'y a pas d'erreur ou d'

Cette propriété est un nombre utilisé conjointement avec la propriété DisplayDistanceType pour contrôler la distance à partir de laquelle la barre de santé d'un humanoid peut être vue.

Voir Nom du personnage/Affichage de la santé pour un guide en détail sur le contrôle de l'apparence des noms de personnages et des barres de santé.

Cette propriété contrôle quand la barre de santé d'un humanoid's peut être affichée. Par défaut, cette propriété est réglée sur Class.Humanoid.Health|

Remarquez que cette propriété fonctionne indépendamment de la propriété HealthDisplayDistance du humanoid qui est responsable de la suppression de la barre de santé à certaines distances. Si Humanoid.HealthDisplayType|HealthDisplayType est défini sur Enum.Humanoid

Voir Nom du personnage/Affichage de la santé pour un guide en détail sur le contrôle de l'apparence des noms de personnages et des barres de santé.

Détermine la distance (en studs) du sol lequel le RootPart devrait être quand le humanoid est debout. Le RigType influence la façon dont cette propriété se comporte.

Pour les R15, une hauteur d'hippade appropriée est préset pour assurer la hauteur de la RootPart correcte. La hauteur des jambes n'est pas utilisée. La hauteur globale du humanoid peut être décrite dans la formule suivante :

Height = (0.5 * RootPart.Size.Y) + HipHeight

Pour les R6, HipHeight au lieu de décrire un décentragerelatif. La hauteur globale du humanoid peut être décrite dans la formule suivante :

Height = LeftLeg.Size.Y + (0.5 * RootPart.Size.Y) + HipHeight

Si true , le saut Humanoid avec une force vers le haut égale à la valeur de Humanoid.JumpPower ou la hauteur de 1> Class.Humanoid.JumpHeight1> , en fonction de la valeur de 4> Class.Humanoid.UseJumpPower4> .

Fournit un contrôle sur la hauteur d'un saut Humanoid, dans les studs. La valeur de départ de cette propriété est déterminée par la valeur de StarterPlayer.CharacterJumpHeight, qui est par défaut 7.2.

Bien que le fait de définir cette propriété à 0 empêche effectivement la saut, il est recommandé de désactiver le saut en désactivant l'état Enum.HumanoidStateType.Jumping .

Cette propriété n'est visible que dans la fenêtre propriétés si Humanoid.UseJumpPower est réglé sur faux , car il ne serait pas pertinent sinon (au lieu de cela, 1> Class.Humanoid.JumpPower1> est utilisé).

Détermine la 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 de 50 et est comprise entre 0 et 1000. Notez que les sauts sont également influencés par la propriété Class.Workspace.Gr

Bien que le fait de définir cette propriété à 0 empêche effectivement la saut, il est recommandé de désactiver le saut en désactivant l'état Enum.HumanoidStateType.Jumping .

Cette propriété n'est visible que dans la fenêtre propriétés si Humanoid.UseJumpPower est réglé sur oui , car sinon (au lieu de cela, 1> Class.Humanoid.JumpHeight1> est utilisé).

La valeur maximale d'un humanoid's Health .

La valeur de cette propriété est utilisée avec la propriété Health pour afficher la barre de santé par défaut. Lorsque un humanoid atteint Health , sa barre de santé peut ne pas être affichée, en fonction de sa propriété MaxHealth.

Cette propriété détermine l'angle de pente maximum qu'un humanoïde peut escalader. Si l'angle d'une pente est supérieur à l'angle de pente maximum d'un humanoïde, ils glisseront vers le bas de la pente.

Lorsqu'un personnage apparaît, cette propriété est définie en fonction de la valeur de StarterPlayer.CharacterMaxSlopeAngle .

La valeur de cette propriété est restreinte aux valeurs entre 0° et 89°. Il s'agit par défaut de 89°, afin que les humanoïdes puissent facilement escalader n'importe quelle pente qu'ils veuillent par défaut.

local player = game.Players.LocalPlayer
local char = player.CharacterAdded:wait()
local h = char:FindFirstChild("Humanoid")

h.MaxSlopeAngle = 30

MoveDirection est une propriété de lecture qui décrit la direction dans laquelle un Humanoid marche, en tant que vecteur d'unité ou de longueur force vectorielle. La direction est décrite dans l'espace mondial.

Puisque cette propriété est seulement lue, elle ne peut pas être définie par un Script ou un LocalScript.

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)

La propriété NomDisplayDistance est un nombre utilisé conjointement avec la propriété Humanoid.DisplayDistanceType pour contrôler la distance à partir de laquelle le nom d'un humanoid peut être vu.

Voir Nom du personnage/Affichage de la santé pour un guide en détail sur le contrôle de l'apparence des noms de personnages et des barres de santé.

Contrôle si la barre de nom et de santé d'un humanoid 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'occlusion entièrement.

Dans les cas où le LocalPlayer n'a pas de Humanoid associé avec lui, cette propriété s'applique plutôt à l'objet Humanoid.

Voir Nom du personnage/Affichage de la santé pour un guide en détail sur le contrôle de l'apparence des noms de personnages et des barres de santé.

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)

Détermine si le Humanoid est actuellement dans l'état Enum.HumanoidStateType.PlatformStanding. Lorsque c'est le cas, le Humanoid est dans un état où il tombe librement et ne peut pas mouvement. Ce comportement ressemble à celui de la position assise, sauf que le saut ne libère pas le Humanoid de l'état.

Permet aux développeurs de désactiver le comportement où un joueur meurt si le Neck Character|character est retiré ou déconnecté même pendant un court instant. Cette propriété par défaut est vraie.

RigType décrit si un Humanoid utilise le plateformede caractères R6 hérité ou le plateformede caractères R15 plus récent.

Le R6 utilise 6 Parts visibles, tandis que le R15 utilise 15 Parts visibles. Les R15 ont plus de joints que les R6, ce qui les rend beaucoup plus polyvalents lorsqu'ils sont animés.

Remarquez que si cette propriété est définie incorrectement, la Humanoid ne fonctionnera pas correctement. Par exemple, si le RigType d'un humanoid R15 est réglé sur R6, le Humanoid mourra car il n'y a pas de <

Une référence à l'objet HumanoidRootPart du Humanoid qui contrôle le comportement d'un humanoïde dans le monde 3D. Cette partie est généralement invisible.

Remarquez que dans le cas des personnages de joueurs, RootPart est la même que la Model.PrimaryPart de la modèlisationPlayer.Character.

SeatPart est une référence à la siège dans laquelle un Humanoid est actuellement assis, si nécessaire. La valeur de cette propriété peut être soit un Seat , soit un VehicleSeat. Il sera 2> nul2> si le Humanoid n'est pas actuellement assis dans une siège.

Remarque :

• Pour un boule décrivant si le Humanoid est actuellement assis ou non, voir Humanoid.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é à vrai. Si le Humanoid n'est pas attach

Remarque :

• Le Seat ou VehicleSeat le Humanoid assis sur peut être obtenu en utilisant la propriété 1> Class.Humanoid.SeatPart1>
• Il est possible de détecter quand un Humanoid se sitte en se connectant à l'événement Humanoid.Seated.

Ne pas utiliser Cette propriété ne fonctionne que avec le mode expérimental activé, qui a été entièrement abandonné.

Cette propriété décrit une position 3D dans l'espace où le Player contrôlant ce Humanoid a cliqué avec un Tool équipé.

Cette propriété est principalement utilisée par les outils classiques pour déterminer lequel d'un humanoid vise lorsqu'il active un outil. Si vous donnez à un NPC un lanceur de fusée classique, définissez leur Point cible et puis appelez la fonction Tool:Activate() de l'outil, vous pouvez faire en sorte que le NPC tire une fusée au point cible.

Lorsqu'un personnage apparaît, cette propriété est définie en fonction de la valeur de StarterPlayer.CharacterUseJumpPower qui par défaut est réglée sur true.

Lorsque vous sautez, avec ce paramètre à vrai, la valeur Humanoid.JumpHeight est utilisée pour garantir que les sauts humanoides atteignent cette hauteur. Avec ce paramètre à faux, la valeur Humanoid.JumpPower est utilisée pour appliquer une force vers le haut.

Cette propriété décrit la vitesse à laquelle le Humanoid peut marcher, en studs par seconde. Il s'agit par défaut de la valeur de StarterPlayer.CharacterWalkSpeed (16), ce qui signifie qu'un personnage de joueur peut déplacer 16 studs dans n'importe quelle direction chaque seconde.

Notes

• Lorsqu'il est contrôlé sur un appareil mobile ou sur un gamepad, un humanoid peut marcher plus lentement que sa vitesse de marche WalkSpeed si le joystick de contrôle est déplacé d'un degré graduel du centre.
• Vous pouvez geler un humanoid en place en définissant WalkSpeed sur 0 ; cela empêche le joueur de le déplacer à travers les mécanismes de déplacement par défaut.
• Le script d'animation par défaut fait en sorte que les animations de déplacement d'un humanoid se basent sur la vitesse de déplacement relative de 16 studs/seconde.
• La vitesse à laquelle le Humanoid marche actuellement peut être obtenue en utilisant l'événement Running.

WalkToPart est une référence à une partie que le Humanoid essaie d'atteindre. Cette propriété est habituellement définie lorsqu'une partie est passée en tant que deuxième argument de la fonction Humanoid:MoveTo() du Humanoid.

Lorsque WalkToPart est défini et qu'un humanoid essaie activement de toucher la partie, il continuera à mettre à jour son objectif Vector3 pour être la position de la partie, plus le Humanoid.WalkToPoint traduit dans l'espace d'objet relatif à la rotation de la partie.

Ceci peut être décrit en Lua comme :

goal = humanoid.WalkToPart.CFrame:pointToObjectSpace(humanoid.WalkToPoint)

Grotte

• Définir la valeur de WalkToPart n'est pas suffisant pour faire un début humanoïde après une partie.
• Le Humanoid 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 la cible d'un humanoid atteint son expiration après 8 secondes s'il ne atteint pas sa cible.
• Ceci est fait afin que les PNJ ne se retrouvent pas coincés en attendant Humanoid.MoveToFinished pour lancer.
• Si vous ne voulez pas que cela se produise, vous devez répéter plusieurs fois MoveTo afin que la minuterie se réinitialise.

WalkToPoint décrit la position 3D dans l'espace que un humanoïde essaie d'atteindre, après avoir été invité à le faire par la fonction Humanoid:MoveTo() du humanoïde.

Si un humanoid est configurer, le but est défini en transformant WalkToPoint relatif à la position et la rotation des parties. Si WalkToPart n'est pas configurer, le humanoid essaie de atteindre la position 3D spécifiée par WalkToPoint directement.

Grotte

• La valeur de WalkToPoint doit être modifiée pour que le humanoid commence à marcher vers elle.
• Si vous voulez faire un marché humanoïde à 0,0,0 , vous devriez utiliser la fonction MoveTo du Humanoid.
• Cela peut être modifié à l'avenir.
• L'état de atteindre la cible d'un humanoid atteint son expiration après 8 secondes s'il ne atteint pas sa cible.
• Ceci est fait afin que les PNJ ne se retrouvent pas coincés en attendant Humanoid.MoveToFinished pour lancer.
• Si vous ne voulez pas que cela se produise, vous devez répéter plusieurs fois MoveTo afin que la minuterie se réinitialise.

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)

Cette méthode attache le Accessory spécifié au parent de l'humanoïde.

Lorsque cette méthode est appelée, une Accessory est attachée au personnage en recherchant un Class.

Si le requis Attachment ne peut pas être trouvé, alors le Accessory restera parenté au parent du humanoid mais il sera détaché.

En général, les soudures d'accessoires sont créées sur le serveur, mais elles peuvent être créées sur le client sous certaines conditions. Dans ces situations, les appels côté client à AddAccessory() peuvent ne pas toujours produire le comportement souhaité et vous pouvez utiliser BuildRigFromAttachments() pour for

Paramètres

Retours

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)

Cette méthode assemble une arbre de Motor6D joints pour le Humanoid . Motor6D joints sont requis pour le playback de 1> Class.Animation|Animations1> .

En commençant à partir de la racine du RootPart du humanoïde, cette méthode collecte tous les Attachments parents dans la partie actuelle dont le nom se termine par

Humanoid:BuildRigFromAttachments() échelle également le personnage et définit les couleurs du corps.

Retours

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)

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

Cette fonction cause le Humanoid à entrer dans le donné Enum.HumanoidStateType, décrivant l'activité que le Humanoid est en train de faire.

Veuillez consulter la page Enum.HumanoidStateType pour plus d'informations sur les États spécifiques, car certains ont des noms inintuitifs. Par exemple, Enum.HumanoidStateType.Running décrit un État où les jambes du humanoid sont sur le sol, y compris lorsqu'il est stationnaire.

En raison du comportement par défaut de Humanoid, certaines états seront automatiquement modifiés lorsqu'il est configurer. Par exemple :

• Définir l'état sur Enum.HumanoidStateType.Swimming lorsque le humanoid n'est pas dans l'eau le mettra automatiquement en Enum.HumanoidStateType.GettingUp.
• Puisqu'il n'est pas utilisé, le définition de l'état à Enum.HumanoidStateType.PlatformStanding provoquera le définition automatique de l'état humanoid à Enum.HumanoidStateType.Running.

Voir aussi Humanoid:SetStateEnabled() pour activer ou désactiver un certain état, et Humanoid:GetState() pour obtenir l'état actuel du humanoid.

Paramètres

Retours

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)

Cette fonction fait en sorte que le Humanoid équipe le Tool donné.

L'exemple ci-dessous provoquerait qu'un Player équipe un outil dans un Workspace nommé 'Tool' .

local Players = game:GetService("Players")

local player = Players:FindFirstChildOfClass("Player")
if player and player.Character then
	local humanoid = player.Character:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		local tool = workspace:FindFirstChild("Tool")
		if tool then
			humanoid:EquipTool(tool)
		end
	end
end

Lorsque cette fonction est appelée, le humanoid dééquipera automatiquement n'importe lequel des Tools qu'il a actuellement équipé

Bien qu'ils soient équipés, Tools pour lesquels Tool.RequiresHandle est true ne fonctionnera pas s'ils n'ont pas de contrôleur, qu'il s'agisse d'équiper ou non

Voir aussi :

• Pour déséquiper les outils, utilisez Humanoid:UnequipTools()

Paramètres

Retours

Cette fonction renvoie un tableau d'objets Accessory que le parent de l'humanoid porte actuellement. Tous ces objets Accessory seront inclus, indépendamment de si ils sont attachés ou non.

Si la Humanoid n'a pas d'objets Accessory, un tableau vide sera renvoyé.

Voir aussi Humanoid:AddAccessory() pour attacher un Accessory à un parent d'un humanoid.

Retours

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)

Cette fonction renvoie une copie du cache de l'humanoid's HumanoidDescription qui décrit son apparence actuelle. Cela peut être utilisé pour déterminer rapidement le look d'un personnage et l'attribuer à un autre personnage en utilisant la fonction Humanoid:ApplyDescription().

Voir aussi

• Players:GetHumanoidDescriptionFromUserId() qui renvoie une 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 l'contenude tenue côté serveur.
• Player:LoadCharacterWithHumanoidDescription() qui génère un joueur avec l'apparence de celui qui passe dans HumanoidDescription.

Retours

Cette fonction renvoie ce que Enum.BodyPartR15 est, ou Part est si la partie n'est pas une partie du corps R15. Cette fonction permet aux développeurs de récupérer les parties du corps des joueurs indépendamment de ce que sont les noms de la partie réelle, ce qui retourne un enum.

Il peut être utilisé en conjonction avec Humanoid:ReplaceBodyPartR15() . Par exemple, si une partie du corps d'un joueur touche quelque chose, cette fonction retournera get a part instance. Les développeurs peuvent alors regarder ce que partie du corps a été, comme la tête ou l'épaule. Ensuite, en fonction de ce que cette partie a été, les développeurs peuvent soit effectuer une action de jeu en jeu, soit remplacer cette partie par une autre partie - peut-

Cette fonction peut être utile pour les jeux où la position d'impact est importante. Par exemple, il peut être utilisé pour déterminer si un joueur est touché dans la jambe et puis les ralentir en fonction de l'injure.

Paramètres

Retours

Cette fonction renvoie l'ensemble Enum.Limb qui est associé avec le Part donné. Il fonctionne pour les R15 et R6 rigs, par exemple :

-- Pour R15
print(humanoid:GetLimb(character.LeftUpperLeg))  -- enum.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftLowerLeg))  -- enum.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftFoot))  -- enum.Limb.LeftLeg

-- Pour R6
print(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 du humanoid.

Paramètres

Retours

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

Retours

Cette fonction renvoie le Enum.HumanoidStateType actuel de l'humanoïde, qui décrit l'activité que le Humanoid est en train de faire, telle que la saut ou la natation.

Voir aussi Humanoid:SetStateEnabled() pour activer ou désactiver un certain état, et Humanoid:ChangeState() pour modifier l'état actuel du humanoid.

Retours

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)

La fonction GetStateEnabled renvoie si un Enum.HumanoidStateType est activé pour le Humanoid.

L'état humanoïde décrit l'activité que le humanoïde effectue actuellement.

Lorsqu'un Enum.HumanoidStateType spécifique est désactivé, le humanoid ne peut jamais entrer dans cet état. Ceci est vrai, indépendamment si l'attempt de changer d'état est fait à l'aide de Humanoid:ChangeState() ou du 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 Humanoid état, utilisez Humanoid:SetStateEnabled()

Paramètres

Retours

local humanoid = script.Parent:WaitForChild("Humanoid")

-- Set state
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)

-- Get state
print(humanoid:GetStateEnabled(Enum.HumanoidStateType.Jumping)) -- false

Cette fonction cause le Humanoid à marcher dans la direction donnée Vector3.

Par défaut, la direction est dans les conditionsdu monde, mais si le paramètre relativeToCamera est true, la direction est relative à la CFrame du 1> Class.Workspace.CurrentCamera|CurrentCamera1> . En tant que direction négative

humanoid:Move(Vector3.new(0, 0, -1), true)

Lorsque cette fonction est appelée, le Humanoid bougera jusqu'à ce que la fonction soit appelée à nouveau. Cependant, si les scripts de contrôle par défaut sont utilisés, ce Characters sera écrasé lors de l'appel du joueur RunService:BindToRenderStep(). Cela peut être évité en utilisant soit les scripts de contrôle par défaut, soit en appelant cette fonction

Cette fonction peut être appelée sur le serveur, mais cela ne doit être fait que lorsque le serveur a propriété du réseau de l'assemblage du humanoid.

Voir aussi Humanoid:MoveTo() qui fait un Humanoid marcher jusqu'à un point, et Player:Move() qui appelle effectivement cette fonction.

Paramètres

Retours

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)

Cette fonction cause le Humanoid à essayer de marcher à l'endroit donné en définissant les propriétés Humanoid.WalkToPoint et Humanoid.WalkToPart.

Les lieux et parties paramètres correspondent à ce que Humanoid.WalkToPoint et 2> Class.Humanoid.WalkToPart2> seront définis.

Si le paramètre pièce est spécifié, le Humanoid tentera toujours de marcher vers le point. Cependant, si la partie se déplace, le point Humanoid que la partie est en train de marcher à sera à la position 2>relative à la partie2>. Si le paramè

L'état atteindre le but d'un humanoid atteindra son but après 8 secondes s'il ne l'atteint pas. Ceci est fait pour que les PNJ ne se retrouvent pas coincés en attendant Humanoid.MoveToFinished pour lancer. Si vous ne voulez pas que cela se produise, vous devriez appeler MoveTo à plusieurs reprises afin que le temps limite se rafraîchisse.

MoveTo() se termine si l'une des conditions suivantes s'applique :

• Le personnage arrive à sa destination.

• Le personnage est coincé et le minuteur de huit secondes expire.

• La valeur de Humanoid.WalkToPoint ou Humanoid.WalkToPart change.

• Un script appelle Humanoid:Move() avec un nouveau moveDirection paramètre.

• Un script change la propriété CFrame de la RootPart.

Paramètres

Retours

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)

Cette fonction supprime tous les objets Accessory portés par le parent de l'humanoïde. Pour le joueur Characters, cela supprime tous les chapeaux et autres accessoires.

Cette fonction supprime l'objet Accessory par le biais de l'appel Instance:Destroy() sur eux, ce qui signifie que le Parent des accessoires est réglé sur 2>nil2> et verrouillé.

Voir également Humanoid:AddAccessory() pour attacher un Accessory et Humanoid:GetAccessories() pour obtenir tous les objets appartenant à un 1> Class.Humanoid1> .

Retours

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)

Remplace dynamiquement une partie de membre R15/Rthro dans un Humanoid par une autre partie. La partie est automatiquement redimensionnée comme d'habitude.

Cette fonction est utile pour modifier des personnages pendant le jeu ou pour construire des personnages à partir d'une base plateforme. La fonction liée GetBodyPartR15 peut être utile lors de l'utilisation de cette fonction.

Le nom de la partie qui passe doit correspondre au nom de l' BodyPartR15 Enum qui passe.

Paramètres

Retours

Cette fonction détermine si un Enum.HumanoidStateType est activé pour le Humanoid. Lorsqu'un Enum.HumanoidStateType est désactivé, le 2> Class.Humanoid2> ne peut jamais entrer dans cet ét

Notez que l'utilisation de SetStateEnabled() sur le serveur ne réplique pas la modification au client, ni vice versa.

Paramètres

Retours

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)

Cette fonction réduit la Humanoid.Health du Humanoid par le montant donné si elle n'est pas protégée par un 2>Class.ForceField2>

Cette fonction accepte les valeurs négatives pour le montant paramètre. Cela augmentera la santé du humanoid Humanoid.Health . Cependant, cela n'aura effet que si aucun ForceField n'est présent.

Comment ForceFields se protégeant contre TakeDamage

Un Humanoid est considéré comme protégé par un ForceField si un ForceField répond à l'un des critères suivants :

• Le ForceField partage le même Instance.Parent que le Humanoid
• Le ForceField est associé à la racine de Humanoid.RootPart de la Humanoid
• Le ForceField est associé à un ancêtre du Humanoid autre que le Workspace

Pour faire des dégâts à un Humanoid irréduction de tout ForceFields présent, définissez Humanoid.Health directement.

Pour plus d'informations sur la façon dont ForceFields protégez Humanoids voir la page ForceField

Paramètres

Retours

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)

Cette fonction dééquipe n'importe lequel des Tool actuellement équipé par le Humanoid

Le Tool non équipé sera associé au Backpack de l'Player associé avec le 1> Class.Humanoid1> .

Si aucun Tool n'est équipé, cette fonction ne fera rien.

Bien que Tools puisse être équipé par les NPCs (non-joueurs), cette fonction ne fonctionne que sur Humanoids avec un correspondant Player . C'est parce que un objet 1> Class.Backpack1> est requis pour parent le 4> Class.Tool

Voir aussi :

• Pour équiper à la place un Tool, utilisez Humanoid:EquipTool()

Retours

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)

Cette fonction d'ajustement fait en sorte que le personnage ressemble à celui du passe dans HumanoidDescription. Une copie du passe HumanoidDescription est mise en cache en tant que HumanoidDescription pour le 1> Class.Humanoid1> .

Cette fonction est optimisée en supposant que seule cette fonction est utilisée pour modifier l'apparence du personnage, et que aucun changement n'est apporté par d'autres moyens entre les appels. Si des modifications sont apportées au personnage entre les appels. alors cette fonction peut ne pas refléter exactement le personnage dans Class.Humanoid

Voir aussi

• Humanoid:GetAppliedDescription() qui renvoie la HumanoidDescription actuellement appliquée au humanoid.
• Players:GetHumanoidDescriptionFromUserId() qui renvoie une 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 l'contenude tenue côté serveur.
• Player:LoadCharacterWithHumanoidDescription() qui génère un joueur avec l'apparence de celui qui passe dans HumanoidDescription.

Paramètres

Retours

Cette fonction d'ajustement fait en sorte que le personnage soit à l'affût de celui du passe dans HumanoidDescription, même après les modifications externes. Une copie du passe HumanoidDescription est stockée en tant que HumanoidDescription pour le 1> Class.Humanoid1> .

Cette fonction garantira toujours que le personnage reflète le caractère passé dans Class.HumanoidDescription</

Paramètres

Retours

Si l'emote ne pouvait pas être joué car le nom de l'emote n'est pas trouvé dans la description humanoïde, cette API renverra une erreur. L'API renverra true pour indiquer que l'emote a été joué avec succès.

Paramètres