Humanoid

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.

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

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

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.

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.

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.

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 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é.

local humanoid = script.Parent

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

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.

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

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.

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é.

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é.

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

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 .

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é).

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é).

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.

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.

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 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 .

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é 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é.

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é.

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 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.

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 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 .

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

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.

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.

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.

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.
• 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 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 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.

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, 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

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

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

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

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

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

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

Retours

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 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 de l'humanoïde.

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

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

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

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 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.

• Un script modifie 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 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

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

Retours

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

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

• Le ForceField partage le même Instance.Parent que le Humanoid
• Le ForceField est parenté au Humanoid.RootPart du Humanoid
• Le ForceField est parenté à un ancêtre du Humanoid autre que le Workspace

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

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 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.