Humanoid

AutoJumpEnabled establece si el Humanoid intentará o no saltar automáticamente sobre un obstáculo que está caminando hacia.

Actualmente, esta propiedad solo funciona cuando se cumplen las siguientes condiciones:

• El modelo de personaje del Humanoid es el Player.Character de un Player .
• El Jugador en cuestión está usando controles táctiles.

Cuando se genera el personaje de un jugador, el valor de la propiedad coincide con la propiedad del jugador Player.AutoJumpEnabled - que a su vez coincide con la propiedad 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 propiedad AutoRotate describe si el Híper Rotará automáticamente para alinearse en la dirección en la que se está moviendo. Cuando se establece en verdadero, el modelo de personaje se girará gradualmente para alinearse con la dirección de su movimiento mientras el Híper Rotará. Cuando se establece en falso, el modelo de personaje se mantendrá fijo en su rotación actual, a menos que se aplique una fuerza giratoria a la Parte de Raíz del Híper.

Si el modelo de personaje sucede ser el personaje de un jugador, entonces el comportamiento de la rotación del Humanoid está influido por la propiedad RotateType de UserGameSettings.

Cuando la propiedad AutoRotate está configurada como verdadera, la propiedad RotateType tiene los siguientes efectos en la rotación del Humanoid:

<tbody>
  <tr>
    <td>Relativo de movimiento</td>

    <td />

    <td />
  </tr>

  <tr>
    <td>Relación de cámara</td>
    <td>El personaje girará para mirar en la dirección de la cámara.</td>
    <td>El jugador tiene su cámara acercada a la primera persona, o está en modo de bloqueo de turno.</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

El Humanoide tiene seis valores de escala de hijos, incluido BodyDepthScale, BodyHeightScale », BodyProportionScale », 1> BodyTypeScale », 4> HeadScale ». Al cambiar el valor de cualquiera de estos factores, las partes y accesorios del c

Determina si se rompen las articulaciones del humanoide cuando están en el estado Enum.HumanoidStateType.Dead . Por defecto, esto es cierto.

La propiedad CameraOffset especifica un desplazamiento a la posición de sujeto de la cámara cuando su Camera.CameraSubject está configurado para este Humanoid .

El desplazamiento se aplica en el espacio de objeto, relativo a la orientación del Humanoid's HumanoidRootPart . Por ejemplo, un valor de desplazamiento Vector3 de (0, 10, 0) desplaza la cámara del jugador a 10 studs por encima del jugador's humanoid.

local RunService = game:GetService("RunService")

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

local function updateBobbleEffect()
	local now = tick()
	if humanoid.MoveDirection.Magnitude > 0 then -- Is the character walking?
		local velocity = humanoid.RootPart.Velocity
		local bobble_X = math.cos(now * 9) / 5
		local bobble_Y = math.abs(math.sin(now * 12)) / 5

		local bobble = Vector3.new(bobble_X, bobble_Y, 0) * math.min(1, velocity.Magnitude / humanoid.WalkSpeed)
		humanoid.CameraOffset = humanoid.CameraOffset:lerp(bobble, 0.25)
	else
		-- Scale down the CameraOffset so that it shifts back to its regular position.
		humanoid.CameraOffset = humanoid.CameraOffset * 0.75
	end
end

RunService.RenderStepped:Connect(updateBobbleEffect)

La propiedad DisplayDistanceType controla el comportamiento de distancia del nombre y la salud de los humanoides. Esta propiedad se establece utilizando el conjunto de propiedades enum.HumanoidDisplayDistanceType con tres valores disponibles, cada uno con su propio conjunto de reglas:

• Cuando se establece en Viewer, el humanoide ve el nombre/salud de otros humanoides dentro de su propio rango de NameDisplayDistance y HealthDisplayDistance .
• Cuando se establece en Subject, el humanoide toma el control completo sobre su propio nombre y estado de salud a través de sus valores NameDisplayDistance y HealthDisplayDistance.
• Cuando se establece a None del modo humano, el nombre y la barra de salud del humano no aparecen bajo ninguna circunstancia.

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

local humanoid = script.Parent

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

DisplayName es una propiedad que determina el nombre de visualización del Humanoid cuando es visible. Por defecto, un nuevo Humanoid tendrá el valor de una cadena vacía. Si DisplayName es una cadena vacía, el nombre de visualización del Humanoid se establecerá por defecto en el nombre de su padre.

Cargando personaje del jugador

Cuando los jugadores cargan su personaje, ya sea automáticamente o a través del uso de LoadCharacter(), el Humanoid que se crea por el motor tendrá su propiedad de DisplayName a la propiedad de DisplayName del jugador.

StarterCharacter y StarterHumanoid

Cuando un Humanoid llamado StarterHumanoid está asociado a StarterPlayer

Esta es una propiedad de solo lectura que describe el Enum.Material que se encuentra actualmente en el Humanoid. Funciona con tanto Parts y 2>Class.Terrain2> como con voces.

El código de abajo muestra cómo escuchar cuando esta propiedad cambia usando Object:GetPropertyChangedSignal() . Cuando el material que está en el suelo cambia, se imprimirá un mensaje que indica que el nuevo material está en el suelo.

local Humanoid = route.to.humanoid

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

Cavernas

• Cuando el Humanoid no esté en un suelo, el valor de esta propiedad se establecerá en Aire.

  • Esto se debe a que las propiedades de lista no pueden tener un valor vacío.
  • Esto puede causar algunas confusiones si se ha establecido el material de una parte en Air, aunque en la práctica, las partes no deben usar ese material en primer lugar.
• El modelo de personaje del Humanoid debe ser capaz de chocar con el suelo, o no se detectará.

  • No puede probar si el Humanoid está nadando con esta propiedad. Debe usar en su lugar su función Humanoid:GetState().

Esta propiedad representa la salud actual del Humanoid. El valor se limita a la gama entre 0 y MaxHealth. Si el humanoid está muerto, esta propiedad se establece continuamente en 0.

Nota que la función TakeDamage() puede usarse para restar de Health en lugar de configurar la propiedad directamente.

Regeneración de Salud

Por defecto, un script de regeneración de salud pasiva se insertará automáticamente en los humanoides. Esto causa que los personajes no muertos de los juegos de salud se regeneren el 1% de MaxHealth cada segundo. Para desactivar este comportamiento de regeneración, agregue un script de salud vacía nombrada Script a Class.StarterCharacterScripts

Mostrar barra de salud

Cuando Health es menor que MaxHealth, se muestra una barra de salud en la experiencia. El comportamiento de la barra de salud depende de la distancia de HealthDisplayDistance y 1> Class.Humanoid.HealthDisplayType|HealthDisplayType

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

Muerte

Cuando el valor de la salud del personaje alcanza 0, el Humanoid se transfiere automáticamente al estado Enum.HumanoidStateType.Dead. En este estado, Health está bloqueado para establecer el 2>Class.Humanoid.Health|Health2>

Esta propiedad es un número que se utiliza en conjunción con la propiedad DisplayDistanceType para controlar la distancia desde la que se puede ver la barra de salud de un humanoid.

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

Esta propiedad controla cuando se permite que la barra de salud de un humanoid se muestre. Por defecto, esta propiedad está configurada como <a href="https://www.microsoft.com/en-us/

Nota que esta propiedad funciona independientemente de la propiedad de HealthDisplayDistance de la cual es responsable de hacer que la barra de salud se desvanezca en ciertas distancias. Si Humanoid.HealthDisplayType|HealthDisplayType está configurado como Enum.H

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

Determina la distancia (en studs) desde el suelo cuando el RootPart debería estar cuando el humanoide está de pie. El RigType afecta la forma en que se comporta esta propiedad.

Para los modelos R15, se preset una altura de eje adecuada para garantizar la altura de la RootPart correcta. La altura de las piernas no se usa. La altura total del humanoid se puede describir en la siguiente fórmula:

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

Para los R6, HipHeight en lugar describe un desplazamiento relativo. La altura total del humanoid se puede describir en la siguiente fórmula:

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

Si true , el salto Humanoid con una fuerza hacia arriba que es igual a la valor de Humanoid.JumpPower o la altura de 1> Class.Humanoid.JumpHeight1>, dependiendo del valor de 4> Class.Humanoid.UseJumpPower4> .

Proporciona control sobre los saltos de altura de un Humanoid saltos, en studs. El valor inicial de esta propiedad se determina por el valor de StarterPlayer.CharacterJumpHeight que se establece por defecto en 7.2.

Aunque establecer esta propiedad a 0 evitará efectivamente que el humanoide salte, se recomienda desactivar el salto desactivando el estado de Enum.HumanoidStateType.Jumping a través de Humanoid:SetStateEnabled() .

Esta propiedad solo es visible en la ventana Propiedades si Humanoid.UseJumpPower está configurado como falso , ya que no sería relevante de otra manera (en cambio, se usa 1> Class.Humanoid.JumpPower1>).

Determina la fuerza hacia arriba que se aplica a la Humanoid cuando salta. El valor inicial de esta propiedad se determina por el valor de StarterPlayer.CharacterJumpPower que es predeterminado para 50 y está limitado entre 0 y 1000. Nota que los saltos también están afectados por la propiedad Class.Workspace

Aunque establecer esta propiedad a 0 evitará efectivamente que el humanoide salte, se recomienda desactivar el salto desactivando el estado de Enum.HumanoidStateType.Jumping a través de Humanoid:SetStateEnabled() .

Esta propiedad solo es visible en la ventana Propiedades si Humanoid.UseJumpPower está configurado como verdadero , ya que no sería relevante de otra manera (en cambio, se usa 1> Class.Humanoid.JumpHeight1>).

El valor máximo de un Health de un humanoide.

El valor de esta propiedad se utiliza junto con la propiedad Health para escalar la pantalla de salud predeterminada. Cuando un humanoid's Health alcanza MaxHealth, su barra de salud puede no mostrarse, dependiendo de su propiedad 2>Class

Esta propiedad determina el ángulo de pendiente máximo que un humanoide puede escalada. Si el ángulo de una pendiente es mayor que el MaxSlopeAngle de un humanoide, se deslizarán por la pendiente.

Cuando se genera un personaje, esta propiedad se establece según el valor de StarterPlayer.CharacterMaxSlopeAngle .

El valor de esta propiedad está limitado a valores entre 0 ° y 89 °. Por defecto, está 89 °, por lo que los humanoides pueden escalar casi cualquier pendiente que quieran por defecto.

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

h.MaxSlopeAngle = 30

MoveDirection es una propiedad de lectura que describe la dirección en la que se está caminando un Humanoid como un vehículo de unidad o un fuerza vectorialde longitud cero. La dirección se describe en el espacio del mundo.

Dado que esta propiedad es solo de lectura, no puede ser establecida por un Script o 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 propiedad Nombre de distancia de visualización es un número que se utiliza en conjunción con la propiedad Humanoid.DisplayDistanceType para controlar la distancia desde la cual se puede ver el nombre de un humanoid.

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

Controla si la barra de nombre y salud de un humanoide se puede ver detrás de paredes o otros objetos. Esta propiedad es un valor de Enum.NameOcclusion y se puede configurar para ocultar todos los nombres, nombres de enemigos o desactivar la ocultación completamente.

En los casos en que el LocalPlayer no tiene asociado ningún Humanoid con él, esta propiedad se aplica en su lugar a la materia Humanoid .

Vea Nombre/Salud de Personaje para obtener una guía en profundidad sobre cómo controlar la apariencia de los nombres de personajes y las barras de salud.

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)

Determina si el Humanoid está actualmente en el estado Enum.HumanoidStateType.PlatformStanding. Cuando es así, el Humanoid está en un estado en el que es de caída libre y no se puede herramienta de movimiento. Este estado se comporta similar al de sentarse, excepto que saltar no libera el humanoid del estado.

Permite a los desarrolladores desactivar el comportamiento donde un jugador muere si el cuello se elimina o se desconecta incluso en un momento. Esta propiedad predeterminada es verdadera.

RigType describe si un Humanoid está utilizando el rigde personaje legado R6 o el rigde personaje más nuevo R15.

El R6 utiliza 6 visible Parts mientras que el R15 utiliza 15 visible Parts . Los R15 tienen más articulaciones que los R6, lo que los hace mucho más versátiles cuando se animan.

Nota que si esta propiedad se establece incorrectamente, el Humanoid no funcionará correctamente. Por ejemplo, si se establece el RigType de un R15 a R6, el Humanoid morirá, ya que no hay 2>Class.Base

Una referencia al objeto raíz humanoide del objeto, la parte de conducción de raíz del Humanoid que controla el movimiento de un humanoide a través del mundo 3D. Esta parte generalmente es invisible.

Nota que en el caso de los personajes del jugador, RootPart es lo mismo que el Model.PrimaryPart del aplicación de modeladoPlayer.Character.

SeatPart es una referencia a la asiento que un Humanoid está sentado en, si corresponde. El valor de esta propiedad puede ser cualquier Seat o VehicleSeat. Será 2> nulo2> si el Humanoid no está sentado en una asiento.

Nota:

• Para un valor que describe si el Humanoid está sentado o no, ve a Humanoid.Sit

La propiedad Sit es una propiedad de valor que indica si el Humanoid está sentado actualmente. Humanoids puede ser forzado a un estado de sentado estableciendo el valor de esta propiedad a true. Si el Humanoid no está asociado a un asiento mientras que está

Nota:

• El Seat o VehicleSeat que se sienta en puede ser obtenido usando la propiedad Humanoid
• Es posible detectar cuando un Humanoid se sienta conectando al evento Humanoid.Seated .

No usar Esta propiedad solo funciona con el Modo Experimental activado, que se ha descontinuado por completo.

Esta propiedad describe una posición 3D en el espacio donde el Player que controla este Humanoid último fue clicado con un Tool equipado.

Esta propiedad se utiliza principalmente por las herramientas clásicas para determinar qué es un humanoide cuando activa una herramienta. Si le das a un NPC un lanzador de cohetes clásico, establece su punto de destino y luego llama la función Tool:Activate() de la herramienta, puedes hacer que el NPC dispare un cohete en el punto de destino.

Cuando se genera un personaje, esta propiedad se establece según el valor de StarterPlayer.CharacterUseJumpPower que predetermina ser cierto.

Al saltar, con este conjunto a la verdad, el valor de Humanoid.JumpHeight se usa para garantizar que los saltos de humanoides a esa altura. Con este conjunto a falso, el valor de Humanoid.JumpPower se usa para aplicar una fuerza hacia arriba.

Esta propiedad describe con qué rapidez el Humanoid puede caminata, en studs por segundo. Por defecto, tiene el valor de StarterPlayer.CharacterWalkSpeed (16), lo que significa que un personaje de jugador puede mover 16 studs en cualquier dirección cada segundo.

Notas

• Cuando se controla en un dispositivo móvil o una consola de juegos, un humanoide puede caminar más lento que su WalkSpeed si el joystick de control se mueve solo un grado gradual desde el centro.
• Puede congelar un humanoide en su lugar al establecer WalkSpeed a 0; esto evita que el jugador controlador lo mueva a través de los mecanismos de movimiento por defecto.
• El guión de animación predeterminado escala las animaciones de movimiento de un humanoide en función de la velocidad relativa con la que se mueve en relación con la velocidad predeterminada de 16 studs / segundo.
• La velocidad a la que se está caminando actualmente el Humanoid se puede obtener utilizando el evento Running

WalkToPart es una referencia a una parte que el Humanoid está tratando de alcanzar. Esta propiedad se establece normalmente cuando se pasa una parte como el segundo argumento de la función Humanoid:MoveTo() del Humanoid.

Cuando WalkToPart está configurado y un humanoide está tratando activamente de alcanzar la parte, seguirá actualizando su objetivo de Vector3 para ser la posición de la parte, plus la Humanoid.WalkToPoint traducida en el espacio de objetos relativo a la rotación de la parte.

Esto se puede describir en Lua como:

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

Cavernas

• Configurar el valor de WalkToPart no es suficiente para hacer un inicio humanoide después de una parte.
• Se le solicita al Humanoide comenzar a intentar alcanzar un objetivo cuando se cambia el valor de WalkToPoint.
• Esto puede cambiarse en el futuro.
• El estado de alcanzar el objetivo de un humanoid se acaba de tiempo después de 8 segundos si no alcanza su objetivo.
• Esto se hace para que los NPC no se queden atascados esperando a que Humanoid.MoveToFinished para desencadenar.
• Si no desea que esto suceda, debe llamar repetidamente a MoveTo para que el tiempo límite se mantenga restablecido.

WalkToPoint describe la posición 3D en el espacio que un humanoide está tratando de alcanzar, después de que se le haya solicitado que lo haga por la función Humanoid:MoveTo() del humanoide.

Si se establecerel Humanoid.WalkToPart de un humanoid, el objetivo se establece al transformar WalkToPoint relativo a la posición y la rotación de las partes. Si no se establecerel Class.Humanoid.WalkToPart de un humanoid, entonces el humanoid intentará alcanzar la posición y la rotación especificadas por WalkToPoint directamente.

Cavernas

• El valor de WalkToPoint debe cambiarse a un valor diferente para que el humanoide comience a caminar hacia él.
• Si desea crear un paseo humanoide a 0,0,0 , debe usar la función MoveTo del Humanoid.
• Esto puede cambiarse en el futuro.
• El estado de alcanzar el objetivo de un humanoid se acaba de tiempo después de 8 segundos si no alcanza su objetivo.
• Esto se hace para que los NPC no se queden atascados esperando a que Humanoid.MoveToFinished para desencadenar.
• Si no desea que esto suceda, debe llamar repetidamente a MoveTo para que el tiempo límite se mantenga restablecido.

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)

Este método adhiere el Accessory especificado al padre del humanoide.

Cuando se llama este método, se aplica un <a href="https://developer.microsoft.espacio

Si no se puede encontrar el requerido Attachment, entonces el Accessory seguirá siendo padre del humanoide, pero no se desprenderá.

Tipualmente, las soldaduras de accesorios se crean en el servidor, pero pueden ser creadas en el cliente en ciertas situaciones. En estas situaciones, las llamadas cliente a AddAccessory() pueden no siempre producir el comportamiento deseado y puedes usar BuildRigFromAttachments() para

Parámetros

Devuelve

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)

Este método asigna un árbol de Motor6D juntas para el Humanoid . Se requieren juntas de Motor6D para la reproducción de 1> Class.Animation|Animaciones1> .

Desde el RootPart del humanoide, este método recoge todos los Attachments padres en la parte actual cuyo nombre termina con RigAppearance

Humanoid:BuildRigFromAttachments() también escala el personaje y establece los colores del cuerpo.

Devuelve

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

Esta función hace que la Humanoid ingrese al dado Enum.HumanoidStateType, que describe la actividad que la Humanoid está realizando.

Por favor, revisa la página Enum.HumanoidStateType para obtener más información sobre los estados en particular, ya que algunos tienen nombres inintuitivos. Por ejemplo, Enum.HumanoidStateType.Running describe un estado en el que las piernas del humano están en el suelo, incluida la posición estática.

Debido al comportamiento predeterminado de la Humanoid , algunos estados se cambiarán automáticamente al establecerse. Por ejemplo:

• Establecer el estado en Enum.HumanoidStateType.Swimming cuando el humano no está en el agua lo hará automáticamente Enum.HumanoidStateType.GettingUp .
• Como no está usado, establecer el estado en Enum.HumanoidStateType.PlatformStanding hará que el estado humanoide se establezca automáticamente en Enum.HumanoidStateType.Running .

Vea también Humanoid:SetStateEnabled() para habilitar o deshabilitar un estado específico, y Humanoid:GetState() para obtener el estado actual del humanoide.

Parámetros

Devuelve

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)

Esta función hace que el Humanoid lleve el dado Tool .

El ejemplo de abajo haría que un Player equipara una herramienta en Workspace llamada 'Herramienta' .

local Players = game:GetService("Players")

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

Cuando se llama esta función, el humanoid desequipará automáticamente cualquier Tools que tenga actualmente equipado

Aunque estarán equipados, Tools para los cuales Tool.RequiresHandle no funcionará si no tienen controlador, independientemente de si esta función se usa para equiparlos o no

Véase también:

• Para desequipar herramientas, usa Humanoid:UnequipTools()

Parámetros

Devuelve

Esta función devuelve un arreglo de Accessory objetos que el padre del humanoide está usando actualmente. Todos estos objetos de clase de accesorios se incluirán, independientemente de si están o no asociados.

Si el Humanoid no tiene objetos de clase Accessory, se devolverá un arreglo vacío.

Vea también Humanoid:AddAccessory() para unir un Accessory a un padre de humanoid.

Devuelve

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)

Esta función devuelve una copia del almacenado de HumanoidDescription que describe su apariencia actual. Esto se puede usar para determinar rápidamente el aspecto de un personaje y asignar su apariencia a otros personajes usando la función Humanoid:ApplyDescription().

Ver también

• Players:GetHumanoidDescriptionFromUserId() que devuelve un HumanoidDescription que describe el avatar para el usuario pasado.
• Players:GetHumanoidDescriptionFromOutfitId() que devuelve un HumanoidDescription cuyos parámetros se inicializan para que coinciden con los que se muestran en el recursode ropa del lado del servidor.
• Player:LoadCharacterWithHumanoidDescription() que genera a un jugador con el aspecto del pasado en HumanoidDescription .

Devuelve

Esta función devuelve lo que Enum.BodyPartR15 es, o Part si la parte no es una parte del cuerpo R15. Esta función permite que los desarrolladores recuperen partes del cuerpo del jugador independientemente de los nombres de las partes del cuerpo reales, en lugar de devolver un enum.

Se puede utilizar en conjunción con Humanoid:ReplaceBodyPartR15() . Por ejemplo, si una parte del cuerpo de un jugador toca algo, esta función devolverá get a part instancia. Los desarrolladores pueden entonces mirar qué parte del cuerpo que estaba, como la cabeza o el brazo. Luego, dependiendo de qué parte fue, los desarrolladores pueden entonces realizar alguna acción de juego o reemplazar esa parte con alguna otra parte - quizás mostrando daño

Esta función puede ser útil para los juegos en los que la ubicación del golpe es importante. Por ejemplo, se puede usar para determinar si un jugador está golpeado en la pierna y luego ralentizarlo según la lesión.

Parámetros

Devuelve

Esta función Enum.Limb devuelve el enum.Limb</enu> que está asociado con el Part dado. Funciona para ambas plataformas R15 y R6, por ejemplo:

-- Para R15
print(humanoid:GetLimb(character.LeftUpperLeg))  -- Enum.Limb.IzquierdaLeg
print(humanoid:GetLimb(character.LeftLowerLeg))  -- Enum.Limb.IzquierdaLeg
print(humanoid:GetLimb(character.LeftFoot))  -- Enum.Limb.IzquierdaLeg

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

Nota que Humanoid:GetLimb() lanzará un error si el padre de la parte no está configurado para el padre del humanoid.

Parámetros

Devuelve

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

Devuelve

Esta función devuelve el estado actual del Enum.HumanoidStateType , que describe la actividad que el Humanoid está realizando, como saltar o nadar.

También vea Humanoid:SetStateEnabled() para habilitar o deshabilitar un estado específico, y Humanoid:ChangeState() para cambiar el estado actual del humanoid.

Devuelve

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 función GetStateEnabled返回是否启用 Enum.HumanoidStateType 中的 Humanoid .

El estado humanoide describe la actividad que el humanoide está realizando actualmente.

Cuando se desactivó un particular Enum.HumanoidStateType el humanoid nunca puede ingresar a ese estado. Esto es cierto independientemente de si se hace el intento de cambiar de estado usando Humanoid:ChangeState() o código humano interno de Roblox.

Véase también:

• Para un evento que se activa cuando se habilita o deshabilita el estado de unoides, consulte Humanoid.StateEnabledChanged
• Para habilitar o deshabilitar un estado de Humanoid usa Humanoid:SetStateEnabled()

Parámetros

Devuelve

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

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

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

Esta función hace que el Humanoid camine en la dirección dada Vector3 .

Por defecto, la dirección está en términos mundiales, pero si el parámetro relativeToCamera es true, la dirección está relativa a la dirección del CFrame del 2>Class.Workspace.CurrentCamera|CurrentCamera2> . Como la dire

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

Cuando se llama esta función, el Humanoid se moverá hasta que se llame la función de nuevo. Sin embargo, si se están utilizando los scripts de control predeterminados, esta función se sobrescribirá cuando se llame al jugador Characters . Esto se puede evitar al no utilizar los scripts de control predeterminados o llamar esta función cada marco usando

Esta función se puede llamar en el servidor, pero esto solo se debe hacer cuando el servidor tenga propiedad de red de la instalación del humanoid.

También se ve Humanoid:MoveTo() que hace que un Humanoid camine hacia un punto, y Player:Move() que efectivamente llama a esta función.

Parámetros

Devuelve

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)

Esta función hace que el Humanoid intente caminar hacia la ubicación proporcionada estableciendo las propiedades Humanoid.WalkToPoint y Humanoid.WalkToPart.

Los parámetros lugar y parte coinciden con lo que Humanoid.WalkToPoint y 1> Class.Humanoid.WalkToPart1> serán establecidos.

Si se especifica el parámetro parte, el Humanoid seguirá intentando caminar hacia el punto. Sin embargo, si el par se mueve, el punto Humanoid que está caminando hacia la posición se moverá para estar en la misma posición 1>relativa

El estado de alcanzar el objetivo de un humanoid se acabará después de 8 segundos si no alcanza su objetivo. Esto se hace para que los NPCs no se queden atascados esperando a que Humanoid.MoveToFinished para desencadenar. Si no quieres que esto suceda, deberás repetiramente llamar MoveTo para que el tiempo de espera se mantenga reiniciado.

MoveTo() termina si se aplica cualquiera de las siguientes condiciones:

• El personaje llega a su destino.

• El personaje se queda atascado y el temporizador de ocho segundos expira.

• El valor de ambos Humanoid.WalkToPoint o Humanoid.WalkToPart cambia.

• Un script llama a Humanoid:Move() con un nuevo parámetro moveDirection .

• Un script cambia la propiedad de CFrame de RootPart .

Parámetros

Devuelve

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)

Esta función elimina todos los objetos Accessory usados por el padre del humanoide. Para el jugador Characters, esto eliminará todos los sombreros y otros accesorios.

Esta función elimina el objeto Accessory por llamar Instance:Destroy() en ellos, lo que significa que el Parent de los accesorios está configurado como 2>nil2> y está bloqueado.

También vea Humanoid:AddAccessory() para agregar un Accessory y Humanoid:GetAccessories() para obtener todos los objetos 1> Class.Accessory1> que pertenecen a un 4> Class.Humanoid4> .

Devuelve

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)

Reemplaza dinámicamente una parte de la extremidad R15/Rthro en un Humanoid con una parte diferente. La parte se escala automáticamente como lo haría normalmente.

Esta función es útil para modificar personajes durante el juego o construir personajes desde una base de rig. La función relacionada GetBodyPartR15 puede ser útil cuando se utiliza esta función.

El nombre de la parte que se pasó debe coincidir con el nombre de la BodyPartR15 Enum pasada.

Parámetros

Devuelve

Esta función establece si un Enum.HumanoidStateType en particular está habilitado para el Humanoid . Cuando un Enum.HumanoidStateType en particular está deshabilitado, el 1> Class.Humanoid1>

Tenga en cuenta que el uso de SetStateEnabled() en el servidor no replica el cambio al cliente, ni viceversa.

Parámetros

Devuelve

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)

Esta función reduce el Humanoid.Health del Humanoid por el valor dado si no está protegido por un campo de fuerza

Esta función acepta valores negativos para el parámetro cantidad. Esto aumentará el Humanoid.Health del humano. Sin embargo, esto solo tendrá un efecto si no hay ForceField presente.

Cómo ForceFields protege contra TakeDamage

Un Humanoid está considerado protegido por un ForceField si un ForceField cumple con uno de los siguientes criterios:

• El ForceField comparte el mismo Instance.Parent que el Humanoid
• El ForceField está asociado con el Humanoid.RootPart del Humanoid
• El ForceField está asociado a un ancestro del Humanoid fuera del Workspace

Para hacer daño a un Humanoid irrespective de cualquier ForceFields presente, configura Humanoid.Health directamente.

Para obtener más información sobre cómo protege Class.ForceField|ForceFields``Class.Humanoid|Humanoids la página ForceField

Parámetros

Devuelve

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)

Esta función desequipa cualquier Tool actualmente equipado por el Humanoid

El Tool desequipado será padre del Backpack de la Player asociado con el 1> Class.Humanoid1> .

Si no se equipa Tool, esta función no hará nada.

Aunque Tools puede ser equipado por NPCs (no jugadores), esta función solo funciona en Humanoids con un padre correspondiente Player . Esto se debe a que un objeto 1> Class.Backpack1> es requerido para padre del desequipado 4> Class.Tool4>

Véase también:

• Para equipar en su lugar un Tool , use Humanoid:EquipTool()

Devuelve

local Players = game:GetService("Players")
local ContextActionService = game:GetService("ContextActionService")

local player = Players.LocalPlayer

ContextActionService:BindAction("unequipTools", function(_, userInputState)
	if userInputState == Enum.UserInputState.Begin then
		if player.Character then
			local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
			if humanoid then
				humanoid:UnequipTools()
			end
		end
	end
end, false, Enum.KeyCode.U)

Esta función de rendimiento hace que el personaje se vea que coincida con el de la pasada en HumanoidDescription . Una copia de la pasada HumanoidDescription está almacenada como la HumanoidDescription para el 1> Class.Humanoid1> .

Esta función se optimiza al hacer la suposición de que solo esta función se usa para cambiar la apariencia del personaje, y no se hacen cambios a través de otros medios entre llamadas. Si se hacen cambios en el personaje entre llamadas. Entonces esta función puede no hacer que el personaje refleje el pasado en Class.HumanoidDescription

Ver también

• Humanoid:GetAppliedDescription() que devuelve el HumanoidDescription aplicado actualmente al humanoide.
• Players:GetHumanoidDescriptionFromUserId() que devuelve un HumanoidDescription que describe el avatar para el usuario pasado.
• Players:GetHumanoidDescriptionFromOutfitId() que devuelve un HumanoidDescription cuyos parámetros se inicializan para que coinciden con los que se muestran en el recursode ropa del lado del servidor.
• Player:LoadCharacterWithHumanoidDescription() que genera a un jugador con el aspecto del pasado en HumanoidDescription .

Parámetros

Devuelve

Esta función de rendimiento hace que el personaje se vea igual que el de la pasada en HumanoidDescription, incluso después de cambios externos. Una copia del pasado HumanoidDescription está guardada como el HumanoidDescription para el 1> Class.Humanoid1> .

Esta función siempre garantizará que el personaje refleje el pasado en Class.HumanoidDescription

Parámetros

Devuelve

Si el emote no se pudo reproducir porque el emoteName no se encuentra en la descripción del humano, esta API devolverá un error. La API devolverá true para indicar que el emote se ha jugado con éxito.

Parámetros