Humanoid

AutoJumpEnabled sets whether or not the Humanoid will attempt to automatically jump over an obstacle it is walking towards.

Currently, this property only works when the following conditions are true:

• The Humanoid's character model is the Player.Character of a Player.
• The Player in question is using touch controls.

When a player's character spawns, the property's value matches the player's Player.AutoJumpEnabled property - which in turn matches the StarterPlayer.AutoJumpEnabled property.

The Humanoid has six child scale values including BodyDepthScale, BodyHeightScale, BodyProportionScale, BodyTypeScale, BodyWidthScale, HeadScale. Changing the value of any of these causes the character's body parts and accessories to change size, but only if AutomaticScalingEnabled is true.

The AutoRotate property describes whether or not the Humanoid will automatically rotate to face in the direction they are moving. When set to true, the character model will gradually turn to face their movement direction as the Humanoid walks around. When set to false, the character model will remain fixated in its current rotation, unless a rotating force is applied to the HumanoidRootPart.

If the character model happens to be the character of a player, then the behavior of the Humanoid's rotation is influenced by the UserGameSetting's RotateType property.

When the AutoRotate property is set to true, the RotateType property has the following effects on the Humanoid's rotation:

Determines whether the humanoid's joints break when in the HumanoidStateType.Dead state. Defaults to true.

The CameraOffset property specifies an offset to the camera's subject position when its Camera.CameraSubject is set to this Humanoid.

The offset is applied in object-space, relative to the orientation of the Humanoid's HumanoidRootPart. For example, an offset Vector3 value of (0, 10, 0) offsets the player's camera to 10 studs above the player's humanoid.

This property selects the HumanoidCollisionType for R15 and Rthro non-player characters.

The DisplayDistanceType property controls the distance behavior of the humanoid's name and health display. This property is set using the HumanoidDisplayDistanceType enum with three available values, each with their own set of rules:

• When set to Viewer, the humanoid sees the name/health of other humanoids within range of its own NameDisplayDistance and HealthDisplayDistance.
• When set to Subject, the humanoid takes full control over its own name and health display through its NameDisplayDistance and HealthDisplayDistance values.
• When set to None, the humanoid's name and health bar do not appear under any circumstances.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

DisplayName is a property that determines the Humanoid's name display when visible. By default, a new Humanoid will have the value of an empty string. If DisplayName is an empty string, the humanoid's name display will default to the humanoid's parent's name property.

Player Character Loading#

When players load their character, either automatically or through the use of LoadCharacterAsync(), the Humanoid that is created by the engine will have its DisplayName property set to the player's DisplayName property.

StarterCharacter and StarterHumanoid#

When a Humanoid named StarterHumanoid is parented to StarterPlayer, or when a Humanoid is present in a Model named StarterCharacter, the DisplayName property will be respected when Characters are loaded by Players in the game. The engine will only override the DisplayName property of the Humanoid with the DisplayName property of the player if the Humanoid.DisplayName of StarterHumanoid is an empty string.

Used to disable the internal physics and state machine of the Humanoid.

What does turning this off do?#

• No forces - The humanoid will not apply forces to any of its parts. The humanoid will not move the character in any way.
• No sensors - The humanoid will not run any spatial queries to detect floors, ladders, or other obstacles (such as auto-jump).
• No collision changes - The humanoid will not alter the collision state of any of the character parts. By default, only the torso and head have Part.CanCollide enabled.
• No state transitions or replication - The humanoid will not automatically update its state. You can still set humanoid state with a script, but it will not automatically replicate.

What does turning this off not do?#

• State events - If manually setting humanoid states, the events for each of the humanoid's states and StateChanged will still fire, which means the Animate script will still receive them and animate the character based on its current humanoid state.
• Appearance - HumanoidDescription, clothes, accessories and other humanoid rendering behavior.
• Camera and player scripts - The humanoid is still linked to Players and camera scripts, which ensures the camera will continue to follow the Humanoid.RootPart.
• Player input handling - The Humanoid.MoveDirection property will still be updated via the Humanoid:Move() function and PlayerScripts for input.

This is a read-only property that describes the Material the Humanoid is currently standing on. It works with both regular Parts and Terrain voxels.

The code sample below demonstrates how to listen to when this property changes using Object:GetPropertyChangedSignal(). When the material the humanoid is standing on changes, it will print a message indicating the new material being stood on.

local Humanoid = route.to.humanoid

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

Caveats#

• When the Humanoid is not standing on a floor, the value of this property will be set to Air.
  • This occurs because Enum properties cannot have an empty value.
  • This can cause some confusion if a part has its material is set to Air, though in practice, parts are not supposed to use that material in the first place.
• The character model of the Humanoid must be able to collide with the floor, or else it will not be detected.
  • You cannot test if the Humanoid is swimming with this property. You should instead use its Humanoid:GetState() function.

This property represents the current health of the Humanoid. The value is restricted to the range between 0 and MaxHealth. If the humanoid is dead, this property is continually set to 0.

Note that the TakeDamage() function may be used to subtract from Health instead of setting the property directly.

Health Regeneration#

By default, a passive health regeneration script is automatically inserted into humanoids. This causes non-dead player characters to regenerate 1% of MaxHealth each second. To disable this regeneration behavior, add an empty Script named Health to StarterCharacterScripts.

Health Bar Display#

When Health is less than MaxHealth, a health bar is displayed in-experience. The display behavior of the health bar is dependent on the HealthDisplayDistance and HealthDisplayType.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

Death#

When the value of the character's health reaches 0, the Humanoid automatically transitions to the HumanoidStateType.Dead state. In this state, Health is locked to 0; however, there is no error or warning for setting the Health of a dead humanoid to a positive nonzero value.

This property is a number used in conjunction with the DisplayDistanceType property to control the distance from which a humanoid's health bar can be seen.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

This property controls when a humanoid's health bar is allowed to be displayed. By default, this property is set to DisplayWhenDamaged, which makes the health bar only display when a humanoid's Health is less than its MaxHealth. It can also be set to AlwaysOn, which makes the health bar always display, or AlwaysOff, which prevents it from ever displaying.

Note that this property functions independently of the humanoid's HealthDisplayDistance property which is responsible for making the health bar fade out at certain distances. If Humanoid.HealthDisplayType|HealthDisplayType is set to AlwaysOn, it will still fade out depending the how HealthDisplayDistance is configured.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

Determines the distance (in studs) off the ground the RootPart should be when the humanoid is standing. The RigType influences the way this property behaves.

For R15 rigs, a suitable hip height is preset to ensure the height of the RootPart is correct. The height of the legs is not used. The overall height of the humanoid can be described in the following formula:

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

For R6 rigs, HipHeight instead describes a relative offset. The overall height of the humanoid can be described in the following formula:

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

If true, the Humanoid jumps with an upwards force equal to the value of Humanoid.JumpPower or the height of Humanoid.JumpHeight, depending on the value of Humanoid.UseJumpPower.

Provides control over the height a Humanoid jumps, in studs. The starting value of this property is determined by the value of StarterPlayer.CharacterJumpHeight which defaults to 7.2.

Although setting this property to 0 will effectively prevent the humanoid from jumping, it's recommended to disable jumping by disabling the HumanoidStateType.Jumping state through Humanoid:SetStateEnabled().

This property is only visible in the Properties window if Humanoid.UseJumpPower is set to false, as it is not relevant otherwise (instead, Humanoid.JumpPower is used).

Determines how much upwards force is applied to the Humanoid when jumping. The starting value of this property is determined by the value of StarterPlayer.CharacterJumpPower which defaults to 50 and is constrained between 0 and 1000. Note that jumps are also influenced by the Workspace.Gravity property which determines the acceleration due to gravity.

Although setting this property to 0 will effectively prevent the humanoid from jumping, it's recommended to disable jumping by disabling the HumanoidStateType.Jumping state through Humanoid:SetStateEnabled().

This property is only visible in the Properties window if Humanoid.UseJumpPower is set to true, as it is not relevant otherwise (instead, Humanoid.JumpHeight is used).

A reference to the humanoid's Left Leg part. The value of this property will always be nil if the humanoid's RigType is set to R15.

The maximum value of a humanoid's Health.

The value of this property is used alongside the Health property to size the default health bar display. When a humanoid's Health reaches MaxHealth, its health bar may not be displayed, depending on its HealthDisplayType property.

This property determines the maximum slope angle that a humanoid can climb. If the angle of a slope is greater than a humanoid's MaxSlopeAngle, they will slide down the slope.

When a character spawns, this property is set according to the value of StarterPlayer.CharacterMaxSlopeAngle.

The value of this property is constrained to values between 0° and 89°. It defaults to 89°, so humanoids can climb pretty much any slope they want by default.

MoveDirection is a read-only property that describes the direction a Humanoid is walking in, as a unit vector or zero length vector. The direction is described in world space.

Because this property is read-only, it cannot be set by a Script or LocalScript.

The NameDisplayDistance property is a number used in conjunction with the Humanoid.DisplayDistanceType property to control the distance from which a humanoid's name can be seen.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

Controls whether a humanoid's name and health bar can be seen behind walls or other objects. This property is a NameOcclusion value and can be configured to occlude all names, enemy names, or disable occlusion entirely.

In cases where the LocalPlayer has no Humanoid associated with it, this property instead applies to the subject Humanoid.

See Character Name/Health Display for an in-depth guide on controlling the appearance of character names and health bars.

Determines whether the Humanoid is currently in the HumanoidStateType.PlatformStanding state. When true, the Humanoid is in a state where it is free-falling and cannot move. This state behaves similar to sitting, except that jumping does not free the humanoid from the state.

Allows developers to disable the behavior where a player Character|character dies if the Neck Motor6D is removed or disconnected even momentarily. This property defaults to true.

A reference to the humanoid's Right Leg part. The value of this property will always be nil if the humanoid's RigType is set to R15.

RigType describes whether a Humanoid is utilizing the legacy R6 character rig, or the newer R15 character rig.

The R6 rig uses 6 visible Parts while the R15 rig uses 15 visible Parts. R15 rigs have more joints than R6 rigs, making them much more versatile when being animated.

Note that if this property is set incorrectly, the Humanoid will not function correctly. For example, if a R15 humanoid's RigType is set to R6, the Humanoid will die as there is no BasePart called Torso connected to a BasePart called Head.

A reference to the humanoid's HumanoidRootPart object. The HumanoidRootPart is required for all assemblies that include a Humanoid and is the primary driving part of the Humanoid that controls a humanoid's movement through the 3D world. This part is normally invisible and typically resides in the local origin center of the character model.

The HumanoidRootPart is included in all platform-wide avatar characters, and automatically created when a character model is imported into Studio. It's possible to manually add a HumanoidRootPart to a model by adding a Part named HumanoidRootPart and ensuring it's the root part of the assembly.

Use this property to reference the specific HumanoidRootPart without searching the model hierarchy. You can get or set the CFrame of this part to change position or reorient the entire character model.

For R15 or higher-fidelity characters, the Model.PrimaryPart of the Player.Character model is also set to HumanoidRootPart.

While R6 characters also include a HumanoidRootPart, the R6 characters, Model.PrimaryPart is set to the Head part.

SeatPart is a reference to the seat that a Humanoid is currently sitting in, if any. The value of this property can be either a Seat, or a VehicleSeat. It will be nil if the Humanoid is not currently sitting in a seat.

Note:

• For a bool describing if the Humanoid is currently sitting or not, see Humanoid.Sit

The Sit property is a boolean that indicates whether the Humanoid is currently sitting. Humanoids can be forced into a sitting state by setting this property's value to true. If the Humanoid isn't attached to a seat while in its sitting state, it will trip over with no collision in its legs. A Humanoid can escape from the sitting state by jumping.

Note:

• The Seat or VehicleSeat the Humanoid is sitting on can be obtained using the Humanoid.SeatPart property
• It is possible to detect when a Humanoid sits by connecting to the Humanoid.Seated event.

Do not use This property only works with Experimental Mode enabled, which has been entirely discontinued.

This property describes a 3D position in space where the Player controlling this Humanoid last clicked with a Tool equipped.

This property is primarily used by classic tools to determine what a humanoid is targeting when they activate a tool. If you give an NPC a classic rocket launcher, set their TargetPoint, and then call the tool's Tool:Activate() function, you can make the NPC fire a rocket at the target point.

A reference to a humanoid's root driving part. Contrary to the name of this property, it will only point to the Torso part if a humanoid doesn't have a HumanoidRootPart.

When a character spawns, this property is set according to the value of StarterPlayer.CharacterUseJumpPower, which defaults to true.

When jumping, with this set to false, the Humanoid.JumpHeight value is used to ensure the humanoid jumps to that height. With this set to true, the Humanoid.JumpPower value is used to apply an upward force.

This property describes how quickly the Humanoid is able to walk, in studs per second. It defaults to the value of StarterPlayer.CharacterWalkSpeed (16), meaning a player character can move 16 studs in any direction each second.

Notes#

• When controlled on a mobile device or a gamepad, a humanoid can walk slower than its WalkSpeed if the controlling thumbstick is moved just a gradual degree from center.
• You can freeze a humanoid in place by setting WalkSpeed to 0, effectively preventing the controlling player from moving it through the default movement mechanisms. Note, however, that WalkSpeed is a client‑replicated property which can be modified locally, so it should not be used as a security mechanism or as the sole method for preventing humanoid movement.
• The default animation script scales a humanoid's movement animations based on how fast it is moving relative to the default speed of 16 studs/second.
• The speed at which the Humanoid is currently walking can be obtained using the Running event.

WalkToPart is a reference to a BasePart that the humanoid is trying to reach, after having been prompted to do so via the MoveTo() method.

When WalkToPart is set and a humanoid is actively trying to reach the part, it will keep updating its Vector3 goal to be the position of the part, plus the WalkToPoint translated in object space relative to the rotation of the part. This can be described in Luau as:

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

Note that simply setting the value of WalkToPart is not sufficient to make a humanoid start "following" a part. Call MoveTo() to initiate movement.

WalkToPoint describes the 3D position in space that a humanoid is trying to reach, after having been prompted to do so via the MoveTo() method.

If a humanoid's WalkToPart is set, the goal is set by transforming WalkToPoint relative to the part's position and rotation. Otherwise, the humanoid will try to reach the 3D position specified by WalkToPoint directly.

Note that simply setting the value of WalkToPoint is not sufficient to make a humanoid start moving toward a point. Call MoveTo() to initiate movement.

This method attaches the specified Accessory to the humanoid's parent.

When this method is called, an Accessory is attached to the character by searching for an Attachment in the humanoid's parent that shares the same name as an Attachment in the accessory's Handle Part. If one is found, the Handle part will be connected to the parent of the Attachment using a Weld, and the weld will be configured so the Attachments occupy the same space.

If the required Attachment can not be found, then the Accessory will remain parented to the humanoid's parent but it will be unattached.

Typically, accessory welds are created on the server, but they can be created on the client under certain circumstances. In these situations, client-sided calls to AddAccessory() may not always produce the desired behavior and you can use BuildRigFromAttachments() to force the expected weld creation.

Adds a BoolValue to the Humanoid's Status object, whose name is equal to the string passed as the status argument. If the status already exists, a new BoolValue will not be created.

Adds a BoolValue to the Humanoid's Status object, whose name is equal to the name of the Status enum passed as the status argument. If the status already exists, a new BoolValue will not be created.

This yielding method makes the character's look match that of the passed in HumanoidDescription. A copy of the passed HumanoidDescription is cached as the HumanoidDescription for the Humanoid.

This method is optimized through making the assumption that only this method is used to change the appearance of the character, and no changes are made through other means between calls. If changes are made to the character between calls, then this method may not make the character reflect the passed in HumanoidDescription accurately.

This method has been superseded by ApplyDescriptionAsync(), which should be used for all new work.

This yielding method makes the character's look match that of the passed in HumanoidDescription. A copy of the passed HumanoidDescription is cached as the HumanoidDescription for the Humanoid.

This method is optimized through making the assumption that only this method is used to change the appearance of the character, and no changes are made through other means between calls. If changes are made to the character between calls, then this method may not make the character reflect the passed in HumanoidDescription accurately. If you want to use this method in conjunction with other means of updating the character, Humanoid:ApplyDescriptionResetAsync() will always ensure the character reflects the passed in HumanoidDescription.

See Also#

• Humanoid:GetAppliedDescription() which returns the HumanoidDescription currently applied to the humanoid.
• Players:GetHumanoidDescriptionFromUserIdAsync() which returns a HumanoidDescription describing the avatar for the passed in user.
• Players:GetHumanoidDescriptionFromOutfitIdAsync() which returns a HumanoidDescription whose parameters are initialized to match that of the passed in server-side outfit asset.
• Player:LoadCharacterWithHumanoidDescriptionAsync() which spawns a player with the look from the passed in HumanoidDescription.

This yielding method makes the character's look match that of the passed in HumanoidDescription, even after external changes. A copy of the passed HumanoidDescription is cached as the HumanoidDescription for the Humanoid.

This method will always ensure the character reflects the passed in HumanoidDescription, even if changes have been made to the character not using the HumanoidDescription system. This is in contrast to Humanoid:ApplyDescription() which is optimized and may incorrectly apply a HumanoidDescription if the character has been changed by means other than through the HumanoidDescription system.

This method has been superseded by ApplyDescriptionResetAsync(), which should be used for all new work.

This yielding method makes the character's look match that of the passed in HumanoidDescription, even after external changes. A copy of the passed HumanoidDescription is cached as the HumanoidDescription for the Humanoid.

This method will always ensure the character reflects the passed in HumanoidDescription, even if changes have been made to the character not using the HumanoidDescription system (for example not using ApplyDescriptionResetAsync() or ApplyDescriptionAsync()). This is in contrast to ApplyDescriptionAsync() which is optimized and may incorrectly apply a HumanoidDescription if the character has been changed by means other than through the HumanoidDescription system.

This method assembles a tree of Motor6D joints for the Humanoid. Motor6D joints are required for the playback of Animations.

Starting from the humanoid's RootPart, this method collects all Attachments parented in the current part whose name ends with RigAttachment. It then searches for a matching attachment in the character that shares the same name as the attachment. Using those two attachments, a Motor6D joint is generated based on the parts associated with the two attachments and the CFrame of the attachments.

Humanoid:BuildRigFromAttachments() also scales the character and sets body colors.

This method causes the Humanoid to enter the given HumanoidStateType, describing the activity the Humanoid is currently doing.

Please review the HumanoidStateType page for more information on the particular states, as some have unintuitive names. For example, HumanoidStateType.Running describes a state where the humanoid's legs are on the ground, including when stationary.

Due to the default behavior of the Humanoid, some states will automatically be changed when set. For example:

• Setting the state to HumanoidStateType.Swimming when the humanoid is not in the water will cause it to be automatically set to HumanoidStateType.GettingUp.
• As it is unused, setting the state to HumanoidStateType.PlatformStanding will cause the humanoid state to be automatically set to HumanoidStateType.Running.

Note that in order to set the Humanoid state using this method, you must do so from a LocalScript and the client must have network ownership of the Player.Character. Alternatively, you can call this method from a server-side Script, but the server must have network ownership of the player character.

See also Humanoid:SetStateEnabled() to enable or disable a particular state, and Humanoid:GetState() to get the current humanoid state.

This method makes the Humanoid equip the given Tool.

When this method is called, the Humanoid will first automatically unequip all Tools that it currently has equipped.

Although they will be equipped, Tools for which Tool.RequiresHandle is true will not function if they have no handle, regardless if this method is used to equip them or not.

See also Humanoid:UnequipTools().

This method returns an array of Accessory objects that the humanoid's parent is currently wearing. All such Accessory objects will be included, regardless of whether they're attached or not.

If the Humanoid has no Accessory objects, an empty array will be returned.

See also Humanoid:AddAccessory() to attach an Accessory to a humanoid's parent.

This method returns a copy of the humanoid's cached HumanoidDescription which describes its current look. This can be used to quickly determine a character's look and to assign their look to other characters using the Humanoid:ApplyDescriptionAsync() method.

See Also#

• Players:GetHumanoidDescriptionFromUserIdAsync() which returns a HumanoidDescription describing the avatar for the passed in user.
• Players:GetHumanoidDescriptionFromOutfitIdAsync() which returns a HumanoidDescription whose parameters are initialized to match that of the passed in server-side outfit asset.
• Player:LoadCharacterWithHumanoidDescriptionAsync() which spawns a player with the look from the passed in HumanoidDescription.

This method returns what BodyPartR15 a Part is, or BodyPartR15.Unknown if the part is not an R15 body part. This method allows developers to retrieve player body parts independent of what the actual body part names are, instead returning an enum.

It can be used in conjunction with Humanoid:ReplaceBodyPartR15(). For example, if a player's body part touches something, this function will return get a part instance. Developers can then look up what part of the body that was, like head or arm. Then depending on what that part was, developers can either perform some gameplay action or replace that part with some other part - perhaps showing damage.

This method can be useful for games where hit location is important. For example, it can be used to determine if a player is hit in the leg and then slow them down based on the injury.

This method returns the Limb enum that is associated with the given Part. It works for both R15 and R6 rigs, for example:

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

-- For R6
print(humanoid:GetLimb(character:FindFirstChild("Left Leg")))  -- Enum.Limb.LeftLeg

Note that Humanoid:GetLimb() will throw an error if the part's parent is not set to the humanoid's parent.

Returns the Humanoid's intended movement velocity as a Vector3. The result is the product of WalkSpeed, the intended movement direction, and the current percent walk speed. If the Humanoid is not moving, this returns (0, 0, 0).

This method returns an array of all AnimationTracks that are currently being played on the Humanoid. A typical use for this method is stopping currently playing tracks using AnimationTrack:Stop().

Beware that this method will not return AnimationTracks that have loaded but are not playing. If you want to track these you will need to index them manually.

Returns the humanoid's actual physical velocity relative to the surface it is standing on as a Vector3 in world-space orientation. This accounts for moving platforms by subtracting floor velocity from the humanoid's body velocity. Unlike Humanoid:GetMoveVelocity(), which returns the intended input-driven velocity, this reflects the humanoid's true physics-based motion — useful for animation speed scaling or detecting whether a character is actually moving versus pushing against a wall. When the humanoid is airborne, the floor velocity component uses the last cached value from when it was grounded.

This method returns the humanoid's current HumanoidStateType, describing the activity the Humanoid is currently doing, such as jumping or swimming.

See also Humanoid:SetStateEnabled() to enable or disable a particular state, and Humanoid:ChangeState() to change the current humanoid state.

The GetStateEnabled method returns whether a HumanoidStateType is enabled for the Humanoid.

The humanoid state describes the activity the humanoid is currently doing.

When a particular HumanoidStateType is disabled, the humanoid can never enter that state. This is true regardless if the attempt to change state is made using Humanoid:ChangeState() or Roblox internal humanoid code.

See also:

• For an event that fires when a humanoid state is enabled or disabled see Humanoid.StateEnabledChanged
• To enable or disable a Humanoid state use Humanoid:SetStateEnabled()

The GetStatuses method returns a table of the Humanoid's statuses, and custom statuses.

The HasCustomStatus method returns boolean based on if custom statuses exist.

The HasStatus method returns a boolean based on if a status exists.

This method loads an Animation onto a Humanoid, returning an AnimationTrack that can be used for playback.

This method causes the Humanoid to walk in the given Vector3 direction.

By default, the direction is in world terms, but if the relativeToCamera parameter is true, the direction is relative to the CFrame of the CurrentCamera. As the negative Z direction is considered "forwards" in Roblox, the following code will make the humanoid walk in the direction of the CurrentCamera.

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

When this method is called, the Humanoid will move until the method is called again. However, this method will be overwritten in the next frame by Roblox's default character control script. This can be avoided by either calling this function every frame using RunService:BindToRenderStep() (see example), or overwriting the control scripts in StarterPlayerScripts.

This method can be called on the server, but this should only be done when the server has network ownership of the humanoid's assembly.

See also Humanoid:MoveTo() which makes aHumanoid walk to a point, and Player:Move() which effectively calls this function.

This method causes the Humanoid to attempt to walk to a given location by setting the WalkToPoint and WalkToPart properties, corresponding to the location and part parameters.

If the part parameter is specified, the Humanoid will still attempt to walk to the location parameter's point. However, if the part moves, the point will move to be at the same position relative to the part.

Note that the movement operation will time out after 8 seconds if the humanoid doesn't reach its goal (this timeout exists so that humanoids do not get stuck waiting for MoveToFinished to fire). If you don't want this to happen, call MoveTo() at a repeated interval so that the timeout keeps resetting.

MoveTo() ends if any of the following conditions apply:

• The character arrives at its destination, assuming a ~1 stud threshold to account for various humanoid speeds and framerates.

• The character gets stuck and the timer expires.

• The value of either WalkToPoint or WalkToPart changes.

• A script calls Move() with a new moveDirection parameter.

• A script changes the CFrame property of the humanoid's RootPart.

This yielding method looks up the emote by name in the HumanoidDescription currently applied to the Humanoid and plays it. If the emote cannot be found in the HumanoidDescription, the method errors.

This method has been superseded by PlayEmoteAsync(), which should be used for all new work.

If the emote could not be played because the emoteName is not found in the HumanoidDescription, this method will give an error. The method will return true to indicate that the emote was played successfully.

This method removes all Accessory objects worn by the humanoid's parent. For player Characters, this will remove all hats and other accessories.

This method removes Accessory object by calling Instance:Destroy() on them, meaning the Parent of the accessories are set to nil and locked.

See also Humanoid:AddAccessory() to attach an Accessory, and Humanoid:GetAccessories() to get all Accessory objects belonging to a Humanoid.

The RemoveCustomStatus method removes the defined custom status from the Status model in the Humanoid..

The RemoveStatus method removes the defined status from the Status model in the Humanoid.

Dynamically replaces a R15/Rthro limb part in a Humanoid with a different part. The part is automatically scaled as normal.

This method is useful for modifying characters during gameplay or building characters from a base rig. The related method GetBodyPartR15 can come in handy when using this method.

The name of the part passed in should match with the name of the BodyPartR15 Enum passed in.

This method sets whether a given HumanoidStateType is enabled for the Humanoid. When a particular HumanoidStateType is disabled, the Humanoid can never enter that state. This is true regardless if the attempt to change state is made using Humanoid:ChangeState() or Roblox internal Humanoid code.

Note that using SetStateEnabled() on the server does not replicate the change to the client, nor vice-versa.

This method lowers the Humanoid.Health of the Humanoid by the given amount if it is not protected by a ForceField

This method accepts negative values for the amount parameter. This will increase the humanoid's Humanoid.Health. However this will only have an effect if no ForceField is present.

How do ForceFields protect against TakeDamage#

A Humanoid is considered protected by a ForceField if a ForceField meets one of the following criteria:

• The ForceField shares the same Instance.Parent as the Humanoid
• The ForceField is parented to the Humanoid.RootPart of the Humanoid
• The ForceField is parented to an ancestor of the Humanoid other than the Workspace

To do damage to a Humanoid irrespective of any ForceFields present, set Humanoid.Health directly.

For more information on how ForceFields protect Humanoids see the ForceField page.

This method unequips any Tool currently equipped by the Humanoid. The unequipped Tool will be parented to the Backpack of the Player associated with the Humanoid.

If no Tool is equipped, this method will do nothing.

Although Tools can be equipped by NPCs, this method only works on Humanoids with a corresponding Player, as a Backpack object is required to parent the unequipped Tool to.

See also Humanoid:EquipTool().

The AnimationPlayed event fires when an AnimationTrack begins playing on the Humanoid.

A common use for this function is to connect the AnimationTrack.KeyframeReached event for the playing AnimationTrack, so additional effects can be added to the animation (for example Sounds and ParticleEmitters).

This event can be used for any Humanoid regardless if it belongs to the local player's client or not.

See also:

• For the AnimationController equivalent of this event, please see AnimationController.AnimationPlayed

Fires when the Humanoid finishes applying a HumanoidDescription to the character, at the end of Humanoid:ApplyDescriptionAsync() or Humanoid:ApplyDescriptionResetAsync(). The description parameter is the HumanoidDescription that was applied.

The event fires on the server and replicates to clients, so server or client listeners can respond when the character's appearance has been updated.

Fires when the speed at which a Humanoid is climbing changes.

Humanoids can climb up ladders made out of Parts or TrussParts.

Humanoids climb at 70% of their Humanoid.WalkSpeed.

This event will not always fire with a speed of 0 when the Humanoid stops climbing.

See also:

• For swimming and running see the Humanoid.Swimming and Humanoid.Running events
• You can also detect when a Humanoid is climbing using the Humanoid.StateChanged event
• You can disable climbing using the Humanoid:SetStateEnabled() function

The CustomStatusAdded event fires when a status is added to the Humanoid via the Humanoid:AddCustomStatus() method.

The CustomStatusRemoved event fires when a status is removed from the Humanoid via the Humanoid:RemoveCustomStatus() method.

This event fires when the Humanoid dies, usually when Humanoid.Health reaches 0. This could be caused either by disconnecting their head from their Humanoid.Torso, or directly setting the health property.

This event only fires if the Humanoid is a descendant of the Workspace. If the Dead HumanoidStateType is disabled it will not fire.

The FallingDown event fires when the Humanoid enters and leaves the FallingDown HumanoidStateType.

The Humanoid will enter the GettingUp state 3 seconds after the FallingDown state is enabled. When this happens this event will fire with an active value of false, and Humanoid.GettingUp will fire with an active value of true.

This event fires when the Humanoid enters or leaves the Freefall HumanoidStateType.

The active parameter represents whether the Humanoid is entering or leaving the Freefall state.

Although the Freefall state generally ends when the Humanoid reaches the ground, this event may fire with active equal to false if the state is changed while the Humanoid is falling. For this reason, you should use Humanoid.StateChanged and listen for the Landed state to work out when a Humanoid has landed.

This event fires when the Humanoid enters or leaves the HumanoidStateType.GettingUp state, a transition state that is activated shortly after the Humanoid enters the FallingDown (3 seconds) or Ragdoll (1 second) states.

When a Humanoid attempts to get back up, this event will first fire with an active parameter of true before shortly after firing again with an active parameter of false.

To force a Humanoid to fall over, use the Humanoid:ChangeState() function with HumanoidStateType.FallingDown.

This event fires when the Humanoid.Health changes. However, it will not fire if the health is increasing from a value equal to or greater than the Humanoid.MaxHealth.

When Humanoid.Health reaches zero, the Humanoid will die and the Humanoid.Died event will fire. This event will fire with a value of zero.

This event fires when the Humanoid enters and leaves the Jumping HumanoidStateType.

When a Humanoid jumps, this event fires with an active parameter of true before shortly afterwards firing again with an active parameter of false. This second firing does not correspond with a Humanoid landing; for that, listen for the Landed HumanoidStateType using Humanoid.StateChanged.

You can disable jumping using the Humanoid:SetStateEnabled() function.

This event fires when the Humanoid finishes walking to a goal declared by the Humanoid.WalkToPoint and Humanoid.WalkToPart properties.

The Humanoid.WalkToPoint and Humanoid.WalkToPart properties can be set individually, or using the Humanoid:MoveTo() function.

If the Humanoid reaches its goal within 8 seconds, this event will return with reached as true. If the goal is not reached within 8 seconds the Humanoid will stop walking and reached will be false. This timeout can be reset be calling Humanoid:MoveTo() again within the timeout period.

This event fires when the Humanoid enters or leaves the PlatformStanding HumanoidStateType.

Whilst the Humanoid is in the PlatformStanding state, the Humanoid.PlatformStand property will be true.

Whilst Humanoid.PlatformStand is set to true, the Humanoid will be unable to move. For more information please see the page for Humanoid.PlatformStand.

The PlatformStand HumanoidStateType was associated with the now disabled Platform part. Despite this, it can still be used by developers.

This event fires when the Humanoid enters or leaves the Ragdoll HumanoidStateType.

The active parameter will have the value true or false to indicate entering or leaving.

Use Humanoid:SetStateEnabled() to disable the GettingUp state to stay in the Ragdoll state.

See also:

• Humanoid.FallingDown for the Humanoid event connected with the FallingDown state, which behaves similarly to Ragdoll

This event fires when the speed at which a Humanoid is running changes.

While running Humanoids cover, on average, their Humanoid.WalkSpeed in studs per second.

When the Humanoid stops running this event will fire with a speed of 0.

See also:

• For swimming and climbing see the Humanoid.Swimming and Humanoid.Climbing events
• You can also detect when a Humanoid is running using the Humanoid.StateChanged event

This event fires when a Humanoid either sits in or gets up from a Seat or VehicleSeat.

When a character comes into contact with a seat, they are attached to the seat and a sitting animation plays. For more information on this, see the Seat page.

• If the character is sitting down, the active parameter will be true and currentSeatPart will be the seat they are currently sitting in.
• If the character got up from a seat, the active parameter will be false and currentSeatPart will be nil.

See also:

• Humanoid.Sit, which indicates if a Humanoid is currently sitting
• Humanoid.SeatPart, which indicates the seat a Humanoid is currently sitting in, if any.

This event fires when the state of the Humanoid is changed.

As there is no "idle" humanoid state, you should instead use the Humanoid.Running event or listen to the RootPart part's Velocity to work out when the Humanoid is standing still.

See Also#

• Humanoid:GetState() and Humanoid:ChangeState() to get and set the state.
• Humanoid:SetStateEnabled() to enable and disable specific states.

The StateEnableChanged event fires when Humanoid:SetStateEnabled() is called on the Humanoid.

Parameters include the HumanoidStateType in question along with a bool indicating if this state is now enabled.

See also:

• To find if a state is currently enabled, use Humanoid:GetStateEnabled()
• To listen to Humanoid state changes use Humanoid.StateChanged

The StatusAdded event fires when a status is added to the Humanoid.

The StatusRemoved event fires when a status is removed from the Humanoid.

This event does not fire when the Humanoid is strafing and should not be used by developers

This event is fired when the Humanoid enters or leaves the StrafingNoPhysics HumanoidStateType.

When the Humanoid enters the StrafingNoPhysics state this event will fire with an active parameter of true. The event will fire again with active equal to false when the Humanoid leaves the StrafingNoPhysics state.

This event is associated with the StrafingNoPhysics Humanoid state and does not fire when the Humanoid is moving perpendicular to the direction it is facing. This state is currently unused, if it is set using Humanoid:ChangeState() the state will revert to RunningNoPhysics.

This event fires when the speed at which a Humanoid is swimming in Terrain water changes.

Humanoids swim at 87.5% of their Humanoid.WalkSpeed.

This event will not always fire with a speed of 0 when the Humanoid stops swimming.

See also:

• For running and climbing see the Humanoid.Running and Humanoid.Climbing events
• You can also detect when a Humanoid is swimming using the Humanoid.StateChanged event
• You can disable swimming using the Humanoid:SetStateEnabled() function

This event fires when one of the humanoid's limbs comes in contact with another BasePart. The BasePart which the limb is touching, along with the limb itself, is given.

This event will not fire when limbs belonging to the Humanoid come into contact with themselves.

Alternatives#

Although the Humanoid.Touched event is useful, you should consider if there are alternatives that better suit your needs.

• In most cases, it's advised to connect a BasePart.Touched event for BaseParts of interest instead, as the Humanoid.Touched event will constantly fire when the humanoid is moving. For example, in a dodgeball game, it would be more practical to connect a Touched event for the balls rather than use Humanoid.Touched.
• When trying to work out when the Humanoid has landed on the ground, the Humanoid.StateChanged event is more suitable. Alternatively, you can check Humanoid.FloorMaterial to see if the humanoid is standing on any non-air material.

Notes#

• Connecting to this event will cause a TouchTransmitter to be created in every limb.
• There is currently no equivalent of BasePart.TouchEnded for Humanoids.