Humanoid

AutoJumpEnabled establece si el Humanoid intentará automáticamente saltar sobre un obstáculo al que se dirige.

Actualmente, esta propiedad solo funciona cuando las siguientes condiciones son ciertas:

• El modelo de personaje del humanoide 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()
	-- Texto del botón de actualización
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Reflejar la propiedad en el personaje del jugador, si tiene uno
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Alternar salto automático
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Actualizar todo lo demás
	update()
end

button.Activated:Connect(onActivated)
update()

La propiedad AutoRotate describe si el Humanoide girará automáticamente hacia la dirección en la que se está moviendo.Cuando se establece en verdadero, el modelo de personaje se volverá gradualmente a la dirección de movimiento del Humanoide mientras camina alrededor.Cuando se establece en falso, el modelo de personaje se mantendrá fijado en su rotación actual, a menos que se aplique una fuerza giratoria al HumanoidRootPart.

Si el modelo de personaje resulta ser el personaje de un jugador, entonces el comportamiento de la rotación del Humanoide se ve influenciado por la propiedad RotateType de UserGameSetting.

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

<th>Comportamiento</th>

    <th>Contexto</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>MovimientoRelativo</td>

    <td />

    <td />
  </tr>

  <tr>
    <td>Relación de cámara</td>

    <td>El personaje girará para enfrentarse en la dirección de la cámara.</td>

    <td>El jugador tiene su cámara enfocada en primera persona o está en modo de bloqueo de cambio.</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 infantil, incluyendo BodyDepthScale , BodyHeightScale , BodyProportionScale , BodyTypeScale , BodyWidthScale , HeadScale .Cambiar el valor de cualquiera de estas causas hace que las partes del cuerpo y los accesorios del personaje cambien de tamaño, pero solo si AutomaticScalingEnabled es verdadero.

Determina si las articulaciones del humanoide se rompen cuando está en el estado Enum.HumanoidStateType.Dead. Se prefiere la verdad.

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

El desplazamiento se aplica en el espacio del objeto, en relación con la orientación de la parte raíz humana del Humanoide HumanoidRootPart.Por ejemplo, un valor de desplazamiento Vector3 de (0, 10, 0) desplaza la cámara del jugador a 10 metros por encima del humanoide del jugador.

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 Distancia de visualización tipo controla el comportamiento de distancia del nombre y la salud del humanoide.Esta propiedad se establece usando el enum 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 del rango de su propio NameDisplayDistance y HealthDisplayDistance .
• Cuando se establece en , el humanoide toma control completo sobre su propio nombre y la visualización de su salud a través de sus valores y .
• Cuando se establece en None, el nombre y la barra de salud del humanoide no aparecen bajo ninguna circunstancia.

Vea Nombre/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y barras de salud.

local humanoid = script.Parent

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

DisplayName es una propiedad que determina la visualización del nombre del Humanoide cuando es visible.Por defecto, un nuevo Humanoide tendrá el valor de una cadena vacía.Si DisplayName es una cadena vacía, la pantalla de nombre del humanoide se mostrará por defecto con la propiedad de nombre del padre del humanoide.

Carga del personaje del jugador

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

StarterCharacter y StarterHumanoid

Cuando un Humanoid llamado StarterHumanoid es padre de StarterPlayer , o cuando un Humanoide está presente en un Modelo llamado StarterCharacter , la propiedad DisplayName se respetará cuando los personajes se carguen por los jugadores en el juego.El motor solo anulará la propiedad DisplayName de la Humanoid con la propiedad DisplayName del jugador si la Humanoid.DisplayName de StarterHumanoid es una cadena vacía.

Esta es una propiedad de solo lectura que describe el Enum.Material el Humanoid está actualmente parado en.Funciona con ambos vóxeles regulares Parts y Terrain vóxeles.

El ejemplo de código a continuación muestra cómo escuchar cuando esta propiedad cambia usando Object:GetPropertyChangedSignal() .Cuando el material en el que se encuentra el humanoide cambia, imprimirá un mensaje que indique el nuevo material en el que se está parado.

local Humanoid = route.to.humanoid

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

Caveatas

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

  • Esto ocurre porque las propiedades de Enum no pueden tener un valor vacío.
  • Esto puede causar cierta confusión si una parte tiene su material establecido en Aire, aunque en la práctica, las piezas no se supone que usen ese material en primer lugar.
• El modelo de personaje del Humanoid debe ser capaz de colisionar con el suelo, o de lo contrario no se detectará.

  • No puedes probar si el Humanoid nada con esta propiedad. Deberías usar en su lugar su función Humanoid:GetState().

Esta propiedad representa la salud actual del Humanoid.El valor se restringe al rango entre 0 y MaxHealth .Si el humanoide está muerto, esta propiedad se establece continuamente en 0.

Tenga en cuenta que la función TakeDamage() se puede usar para restar de Health en lugar de establecer la propiedad directamente.

Regeneración de salud

Por defecto, un guión de regeneración de salud pasiva se inserta automáticamente en los humanoides.Esto hace que los personajes no muertos del jugador se regeneren 1% de MaxHealth cada segundo.Para deshabilitar este comportamiento de regeneración, agregue un vacío Script llamado Salud a StarterCharacterScripts .

Mostrador de barra de salud

Cuando Health es menos de MaxHealth, se muestra una barra de salud en la experiencia.El comportamiento de visualización de la barra de salud depende de la HealthDisplayDistance y HealthDisplayType.

Vea Nombre/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y barras de salud.

Muerte

Cuando el valor de la salud del personaje llega a 0, el Humanoid transita automáticamente al estado Enum.HumanoidStateType.Dead.En este estado, Health está bloqueado a 0; sin embargo, no hay error o advertencia por establecer el Health de un humanoide muerto a un valor positivo no nulo.

Esta propiedad es un número que se utiliza junto con la propiedad DisplayDistanceType para controlar la distancia desde la cual se puede ver la barra de salud de un humanoide.

Vea Nombre/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y barras de salud.

Esta propiedad controla cuándo se permite mostrar la barra de salud de un humanoide.Por defecto, esta propiedad se establece en DisplayWhenDamaged , lo que hace que la barra de salud solo se muestre cuando el humanoide Health tenga menos de su MaxHealth .También se puede configurar en AlwaysOn , lo que hace que la barra de salud siempre se muestre, o AlwaysOff , lo que impide que nunca se muestre.

Tenga en cuenta que esta propiedad funciona de forma independiente de la propiedad humanoide HealthDisplayDistance que es responsable de hacer desaparecer la barra de salud a ciertas distancias.Si Humanoid.HealthDisplayType|HealthDisplayType está configurado a AlwaysOn, aún se desvanecerá dependiendo de cómo se haya configurado HealthDisplayDistance.

Vea Nombre/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y barras de salud.

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

Para las plataformas R15, una altura de cadera adecuada se predetermina para garantizar que la altura del RootPart sea correcta.No se usa la altura de las piernas.La altura total del humanoide se puede describir en la siguiente fórmula:

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

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

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

Si true , los saltos Humanoid saltan con una fuerza hacia arriba igual al valor de Humanoid.JumpPower o la altura de Humanoid.JumpHeight , dependiendo del valor de Humanoid.UseJumpPower .

Proporciona control sobre la altura de los saltos Humanoid 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 deshabilitar el salto desactivando el estado Enum.HumanoidStateType.Jumping a través de Humanoid:SetStateEnabled().

Esta propiedad solo es visible en la ventana Propiedades si Humanoid.UseJumpPower está configurada como falsa , ya que de lo contrario no sería relevante (en su lugar, se usa Humanoid.JumpPower).

Determina cuánta fuerza hacia arriba se aplica al Humanoid al saltar.El valor inicial de esta propiedad se determina por el valor de StarterPlayer.CharacterJumpPower que se establece en 50 y se ve limitado entre 0 y 1000.Tenga en cuenta que los saltos también se ven influenciados por la propiedad Workspace.Gravity que determina la aceleración debida a la gravedad.

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

Esta propiedad solo es visible en la ventana Propiedades si Humanoid.UseJumpPower está configurada como verdadera , ya que de lo contrario no sería relevante (en su lugar, se usa Humanoid.JumpHeight).

El valor máximo de un humanoide de Health .

El valor de esta propiedad se usa junto con la propiedad Health para dimensionar la pantalla de barra de salud predeterminada.Cuando el bar de salud de un humanoide Health llega a MaxHealth, su barra de salud puede no ser mostrada, dependiendo de su propiedad HealthDisplayType.

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

Cuando un personaje se genera, esta propiedad se establece de acuerdo con el valor de StarterPlayer.CharacterMaxSlopeAngle .

El valor de esta propiedad está restringido a valores entre 0° y 89°.Por defecto es de 89°, por lo que los humanoides pueden escalar prácticamente cualquier pendiente que deseen de forma predeterminada.

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

h.MaxSlopeAngle = 30

MoveDirection es una propiedad de lectura solo que describe la dirección en la que Humanoid camina, como un vector de unidad o fuerza vectorialde longitud cero.La dirección se describe en el espacio mundial.

Debido a que esta propiedad es solo de lectura, no se puede establecer 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 Distancia de visualización del nombre 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/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y barras de salud.

Controla si el nombre y la barra de salud de un humanoide se pueden ver detrás de paredes u otros objetos.Esta propiedad es un valor Enum.NameOcclusion y se puede configurar para excluir todos los nombres, nombres enemigos o desactivar la occlusión por completo.

En casos donde el LocalPlayer no tiene ninguna Humanoid asociada con él, esta propiedad se aplica en cambio al sujeto Humanoid.

Vea Nombre/visualización de salud del personaje para una guía detallada sobre el control de la apariencia de los nombres de personajes y 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 verdadero, el humanoide está en un estado en el que cae libremente y no puede herramienta de movimiento.Este estado se comporta de manera similar a sentarse, excepto que saltar no libera al humanoide del estado.

Permite a los desarrolladores deshabilitar el comportamiento donde un jugador Character|character muere si se elimina o desconecta el cuello Motor6D incluso por un momento.Esta propiedad se predetermina como verdadera.

Tipo de rig describe si un Humanoid está utilizando el antiguo carácter de personaje R6 o el nuevo carácter de personaje R15.

El rig R6 usa 6 visibles Parts mientras que el rig R15 usa 15 visibles Parts .Los equipos R15 tienen más articulaciones que los equipos R6, lo que los hace mucho más versátiles al ser animados.

Tenga en cuenta que si esta propiedad se establece incorrectamente, el Humanoid no funcionará correctamente.Por ejemplo, si el Tipo de rig de un humanoide R15 está configurado como R6, el Humanoid morirá ya que no hay ningún BasePart llamado Torso conectado a un BasePart llamado Cabeza .

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

Para los personajes R15, Model.PrimaryPart del modelo Player.Character se establece en HumanoidRootPart .

Para los personajes R6, Model.PrimaryPart se establece en la parte Head .

SeatPart es una referencia al asiento en el que un Humanoid está sentado actualmente, si es que hay alguno.El valor de esta propiedad puede ser un Seat o un VehicleSeat.Será nulo si el Humanoide no está sentado actualmente en un asiento.

Nota:

• Para un bool que describa si el Humanoid está sentado actualmente o no, vea Humanoid.Sit

La propiedad Sit es un booleano que indica si el Humanoid está sentado actualmente.Humanoids se puede forzar a un estado de inactividad al establecer el valor de esta propiedad en verdadero.Si el Humanoid no está adjunto a un asiento mientras está en su estado de reposo, se tropezará sin colisión en sus piernas.Un Humanoid puede escapar del estado de sentado al saltar.

Nota:

• El Seat o VehicleSeat el Humanoid está sentado en se puede obtener usando la propiedad Humanoid.SeatPart
• Es posible detectar cuando un Humanoide se sienta conectándose al evento Humanoid.Seated.

No use Esta propiedad solo funciona con el modo experimental habilitado, que se ha descontinuado por completo.

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

Esta propiedad es utilizada principalmente por herramientas clásicas para determinar a qué está apuntando 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() del instrumento, puedes hacer que el NPC dispare un cohete al punto de destino.

Cuando un personaje se genera, esta propiedad se establece de acuerdo con el valor de StarterPlayer.CharacterUseJumpPower que se establece como verdadero por defecto.

Al saltar, con este valor establecido en verdad, el valor Humanoid.JumpHeight se usa para garantizar los saltos humanoides a esa altura.Con esto establecido en falso, el valor Humanoid.JumpPower se usa para aplicar una fuerza ascendente.

Esta propiedad describe qué tan rápido puede caminatael Humanoid en studs por segundo.Por defecto, toma el valor de StarterPlayer.CharacterWalkSpeed (16), lo que significa que un personaje de jugador puede mover 16 tachuelas en cualquier dirección cada segundo.

Notas

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

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

Cuando WalkToPart está configurado y un humanoide está tratando activamente de llegar a la parte, mantendrá actualizando su objetivo Vector3 para ser la posición de la parte, más el Humanoid.WalkToPoint traducido en el espacio del objeto en relación con la rotación de la parte.

Esto se puede describir en Luau como:

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

Caveatas

• Establecer el valor de WalkToPart no es suficiente para hacer que un humanoide comience a seguir una parte.
• Al humanoide se le solicita que comience a intentar alcanzar un objetivo cuando el valor de WalkToPoint se cambia.
• Esto puede cambiarse en el futuro.
• El estado de objetivo alcanzado de un humanoide expirará 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 desencadenar.
• Si no quieres que esto suceda, deberías llamar repetidamente a MoveTo para que el tiempo de espera siga reiniciándose.

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 la función Humanoid:MoveTo() del Humanoide.

Si el Humanoid.WalkToPart de un humanoide está establecer, el objetivo se establece transformando WalkToPoint en relación con la posición y rotación de las piezas.Si WalkToPart no está establecer, el humanoide intentará llegar a la posición 3D especificada por WalkToPoint directamente.

Caveatas

• El valor de WalkToPoint debe cambiarse a un valor diferente para que el humanoide empiece a caminar hacia él.
• Si quieres hacer un paseo humanoide a 0,0,0 , deberías usar la función MoveTo del humanoide.
• Esto puede cambiarse en el futuro.
• El estado de objetivo alcanzado de un humanoide expirará 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 desencadenar.
• Si no quieres que esto suceda, deberías llamar repetidamente a MoveTo para que el tiempo de espera siga reiniciándose.

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 une el especificado Accessory al padre del humanoide.

Cuando se llama este método, un se adjunta al personaje al buscar un en el padre del humanoide que comparta el mismo nombre que un en el accesorio de manejo .Si se encuentra uno, la parte de manejo se conectará al padre del Attachment usando un Weld, y se configurará la soldadura para que el Attachments ocupen el mismo espacio.

Si no se puede encontrar el requerido Attachment , entonces el Accessory permanecerá como padre del humanoide, pero se despegará.

Típicamente, las soldaduras accesorias se crean en el servidor, pero se pueden crear en el cliente bajo ciertas circunstancias.En estas situaciones, las llamadas del lado del cliente a AddAccessory() pueden no producir siempre el comportamiento deseado y puedes usar BuildRigFromAttachments() para forzar la creacionesde soldadura esperada.

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 ensambla un árbol de Motor6D uniones para el Humanoid . Las uniones Motor6D son requeridas para la reproducción de Animations .

Comenzando con el padre humanoide de RootPart , este método recoge todos los Attachments padres en la parte actual cuyo nombre termina con RigAttachment .Luego busca un archivo coincidente en el personaje que comparte el mismo nombre que el conexión.Usando esos dos archivos adjuntos, se genera una junta Motor6D basada en las partes asociadas con los dos archivos adjuntos y la CFrame de los archivos adjuntos.

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

Este método hace que el Humanoid entre en el Enum.HumanoidStateType dado, describiendo la actividad que el Humanoid está haciendo actualmente.

Por favor, revisa la página Enum.HumanoidStateType para obtener más información sobre los estados particulares, ya que algunos tienen nombres poco intuitivos.Por ejemplo, Enum.HumanoidStateType.Running describe un estado en el que las piernas del humanoide están en el suelo, incluyendo cuando están estáticas.

Debido al comportamiento predeterminado del Humanoid, algunos estados se cambiarán automáticamente cuando se establecer. Por ejemplo:

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

Tenga en cuenta que para establecer el estado Humanoid usando este método, debe hacerlo desde un LocalScript y el cliente debe tener propiedad de red de la Player.Character.Alternativamente, puedes llamar a este método desde un lado del servidor Script , pero el servidor debe tener la propiedad de red del personaje del jugador.

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

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)

Este método hace que el Humanoid equipar el dado Tool.

El ejemplo a continuación causaría un Player para equipar una herramienta en Workspace llamada 'Herramienta' .

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

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

Cuando se llama este método, el Humanoid primero desequipará automáticamente todo Tools que actualmente tiene equipado.

Aunque estarán equipados, Tools para el cual Tool.RequiresHandle es verdadero no funcionará si no tienen controlador, independientemente de si se usa este método para equiparlos o no.

Vea también:

• Para desequipar herramientas, use Humanoid:UnequipTools()

Parámetros

Devuelve

Este método devuelve un array de Accessory objetos que el padre del humanoide está usando actualmente.Todos esos objetos Accessory se incluirán, independientemente de si están adjuntos o no.

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

Vea también Humanoid:AddAccessory() para adjuntar un Accessory a un padre humanoide.

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)

Este método devuelve una copia del almacenamiento en caché del humanoide HumanoidDescription que describe su aspecto actualEsto se puede usar para determinar rápidamente el aspecto de un personaje y asignar su aspecto a otros personajes usando el método 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 coincidir con el de la asignación de recursodel lado del servidor pasada.
• Player:LoadCharacterWithHumanoidDescription() que genera un jugador con el aspecto de la pasada en HumanoidDescription .

Devuelve

Este método devuelve lo que Enum.BodyPartR15 es un Part o Enum.BodyPartR15.Unknown si la parte no es una parte del cuerpo R15.Este método permite a los desarrolladores recuperar partes del cuerpo del jugador independientemente de cuáles sean los nombres de las partes del cuerpo reales, devolviendo un enumerado en lugar de uno.

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á una instancia de parte.Los desarrolladores pueden entonces buscar qué parte del cuerpo era, como la cabeza o el brazo.Entonces, dependiendo de qué parte era esa, los desarrolladores pueden realizar alguna acción de juego o reemplazar esa parte con alguna otra parte - tal vez mostrando daños.

Este método puede ser útil para juegos donde la ubicación del golpe es importante.Por ejemplo, se puede usar para determinar si un jugador es golpeado en la pierna y luego ralentizarlo según la lesión.

Parámetros

Devuelve

Este método devuelve el enum Enum.Limb que está asociado con el dado Part. Funciona para ambas plataformas R15 y R6, por ejemplo:

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

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

Tenga en cuenta que Humanoid:GetLimb() lanzará un error si el padre de la parte no está configurado como el padre del humanoide.

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

Este método devuelve el Enum.HumanoidStateType, que describe la actividad que el Humanoid, como saltar o nadar.

Vea también Humanoid:SetStateEnabled() para habilitar o deshabilitar un estado particular, y Humanoid:ChangeState() para cambiar el estado humanoide actual.

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)

El método GetStateEnabled devuelve si un Enum.HumanoidStateType está habilitado para el Humanoid .

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

Cuando un determinado Enum.HumanoidStateType está deshabilitado, el humanoide nunca puede entrar en ese estado.Esto es cierto independientemente de si se realiza el intento de cambiar el estado usando Humanoid:ChangeState() o código humanoide interno de Roblox.

Vea también:

• Para un evento que se activa cuando se habilita o deshabilita un estado humanoide, vea Humanoid.StateEnabledChanged
• Para habilitar o deshabilitar un estado Humanoid use 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

Este método 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 es relativa a la CFrame de la CurrentCamera.Como la dirección negativa Z se considera "hacia adelante" en Roblox, el siguiente código hará que el humanoide camine en la dirección de la CurrentCamera.

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

Cuando se llama este método, el Humanoid se moverá hasta que se llame el método de nuevo.Sin embargo, este método será reemplazado en el siguiente marco por el guión de control de personajes predeterminado de Roblox.Esto se puede evitar llamando esta función cada marco usando RunService:BindToRenderStep() (ver ejemplo), o reemplazando los scripts de control en StarterPlayerScripts .

Este método se puede llamar en el servidor, pero esto solo debe hacerse cuando el servidor tenga propiedad de red de la asamblea del humanoide.

Vea también Humanoid:MoveTo() que hace un paseo de Humanoid a 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)

Este método hace que el Humanoid camine hacia la ubicación dada al establecer las propiedades Humanoid.WalkToPoint y Humanoid.WalkToPart.

Los parámetros de ubicación y parte coinciden con lo que y se establecerán.

Si se especifica el parámetro parte, la Humanoid todavía intentará caminar al punto.Sin embargo, si la parte se mueve, entonces el punto que Humanoid camina a estar en la misma posición relativa a la parte .Si no se especifica el parámetro parte, entonces la posición a la que se camina el Humanoid no cambiará.

El estado de objetivo alcanzado de un humanoide expirará 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 desencadenar.Si no quieres que esto suceda, deberías llamar repetidamente a MoveTo para que el tiempo de espera siga reiniciándose.

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

• El personaje llega a su destino. Hay un umbral de ~1 stud para tener en cuenta varias velocidades y framerates humanoides.

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

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

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

• Un script cambia la propiedad CFrame de la 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)

Este método elimina todos los objetos Accessory usados por el padre del humanoide. Para el jugador Characters, esto eliminará todos los sombreros y otros accesorios.

Este método elimina el objeto Accessory llamando a Instance:Destroy() en ellos, lo que significa que el Parent de los accesorios está configurado como nil y bloqueado.

Vea también Humanoid:AddAccessory() para adjuntar un Accessory , y Humanoid:GetAccessories() para obtener todos los objetos Accessory pertenecientes a un 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)

Reemplaza dinámicamente una parte de extremidad R15/Rthro en un Humanoide con una parte diferente. La parte se escala automáticamente como de costumbre.

Este método es útil para modificar personajes durante el juego o para construir personajes a partir de un rigbase.El método relacionado GetBodyPartR15 puede ser útil al usar este método.

El nombre de la parte pasada debe coincidir con el nombre de la BodyPartR15 Enum pasada.

Parámetros

Devuelve

Este método establece si un dado Enum.HumanoidStateType está habilitado para el Humanoid.Cuando un determinado Enum.HumanoidStateType está deshabilitado, el Humanoid nunca puede entrar en ese estado.Esto es cierto independientemente de si se realiza el intento de cambiar el estado usando Humanoid:ChangeState() o código interno de Roblox Humanoid.

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)

Este método reduce el Humanoid.Health de la Humanoid por la cantidad dada ** si no está protegido por un ForceField

Este método acepta valores negativos para el parámetro cantidad.Esto aumentará el humanoide de Humanoid.Health .Sin embargo, esto solo tendrá efecto si no hay ForceField presente.

¿Cómo protegen los campos de fuerza contra el daño por toma

Un Humanoid se considera 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 es padre del Humanoid.RootPart de la Humanoid
• El ForceField está patrocinado por un ancestro del Humanoid diferente al Workspace

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

Para obtener más información sobre cómo ForceFields proteger Humanoids vea 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)