Humanoid

O AutoJumpEnabled configura se o Humanoid vai tentar ou não pular automaticamente sobre um obstáculo que está se movendo em direção a ele.

Atualmente, esta propriedade só funciona quando as seguintes condições estão verdadeiras:

• O modelo de personagem do Humanoid é o Player.Character de um Player .
• O jogador em questão está usando controles de toque.

Quando um personagem de um jogador é gerado, o valor da propriedade corresponde à propriedade do jogador Player.AutoJumpEnabled - que, por sua vez, corresponde à propriedade 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()

A propriedade AutoRotate descreve se o Humanoid girará automaticamente para a direção em que eles estão se movendo. Quando definido como verdadeiro, o modelo de personagem gradualmente se tornará para a direção de movimento do Humanoid enquanto o Humanoid estiver girando. Quando definido como falso, o modelo de personagem permanecerá fixado em sua rotação atual, a menos que uma força girando seja aplicada à parte raiz do humanóide.

Se o modelo de personagem ocorrer ser o personagem de um jogador, então o comportamento da rotação do Humanoid é influenciado pela propriedade RotateType do UserGameSettings.

Quando a propriedade AutoRotate está definida como verdadeira, a propriedade RotateType tem os seguintes efeitos na rotação do Humanoide:

<tbody>
  <tr>
    <td>MovimentoRelativo</td>

    <td />

    <td />
  </tr>

  <tr>
    <td>Relativo à Câmera</td>
    <td>O personagem girará para a frente na direção da Câmera.</td>
    <td>O jogador tem a câmera zoomed para a primeira pessoa ou está no modo de bloqueio de mudança.</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

O Humanoide tem seis valores de escala de filho, incluindo BodyDepthScale, BodyHeightScale, BodyProportionScale, 2> BodyTypeScale2>, 5> HeadScale5>. Alterar o valor de qualquer uma dessas causas faz com que as partes

Determina se as juntas do humanóide são quebradas quando no estado Enum.HumanoidStateType.Dead . Padrões para verdadeiro.

A propriedade CameraOffset especifica um deslocamento para a posição de sujeito da Câmeraquando sua Camera.CameraSubject está definida para esta Humanoid.

O deslocamento é aplicado no espaço de objeto, relativo à orientação do Humanoid'sVector3. Por exemplo, um deslocamento de Datatype.Vector3 de 1> (0, 10, 0)1> desloca a câmera do jogador para 10 studs acima do jogador'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)

A propriedade DisplayDistanceType controla o comportamento de distância do nome e saúde do humanóide. Essa propriedade é definida usando o conjunto de propriedades Enum.HumanoidDisplayDistanceType com três valores disponíveis, cada um com seu próprio conjunto de regras:

• Quando definido para Viewer, o humanóide vê o nome/saúde de outros humanóides dentro do alcance de seu próprio NameDisplayDistance e HealthDisplayDistance.
• Quando definido para Subject, o humanóide leva controle completo sobre seu próprio nome e exibição de saúde através de seus valores NameDisplayDistance e 1> HealthDisplayDistance1>.
• Quando definido para None, o nome e a barra de saúde do humanóide não aparecem sob nenhuma circunstância.

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

local humanoid = script.Parent

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

DisplayName é uma propriedade que determina a exibição de nome de um Humanoid quando visível. Por padrão, um novo Humanoid terá o valor de uma string / cadeia / textovazia. Se DisplayName for uma string / cadeia / textovazia, o nome do humanoid será padrão para a propriedade de nome de seu pai.

Carregando Personagem do Jogador

Quando os jogadores carregam seu personagem, seja automaticamente ou através do uso de LoadCharacter(), o Humanoide que é criado pelo motor terá sua propriedade DisplayName definida para a propriedade DisplayName do jogador.

Personagem Iniciante e StarterHumanoid

Quando um Humanoid chamado StarterHumanoid está ligado ao StarterPlayer, ou

Esta é uma propriedade de leitura que descreve o Enum.Material que o Humanoid está em cima. Funciona com ambos os tipos regulares de Parts e 1> Class.Terrain1> voxels.

O código abaixo mostra como ouvir quando esta propriedade muda usando Object:GetPropertyChangedSignal() . Quando o material que está em cima da cabeça muda, ele imprime uma mensagem indicando que o novo material está em cima da cabeça.

local Humanoid = route.to.humanoid

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

Cavernas

• Quando o Humanoid não estiver em um andar, o valor desta propriedade será definido como Ar.

  • Isso ocorre porque propriedades de Lista não podem ter um valor vazio.
  • Isso pode causar alguma confusão se uma peça tiver seu material definido como Ar, embora na prática, peças não devem usar esse material em primeiro local.
• O modelo de personagem do Humanoid deve ser capaz de colidir com o chão, ou não será detectado.

  • Você não pode testar se o Humanoid está nadando com esta propriedade. Você deve usar em vez disso sua função Humanoid:GetState().

Essa propriedade representa a saúde atual do Humanoid. O valor é restrito à faixa entre 0 e MaxHealth. Se o humanóide estiver morto, essa propriedade é definida continuamente para 0.

Nota que a função TakeDamage() pode ser usada para subtrair do Health em vez de definir a propriedade diretamente.

Regeneração da Saúde

Por padrão, um script de regeneração de saúde passivo é inserido automaticamente em humanóides. Isso causa não mortos personagens de jogador para regenerar 1% de MaxHealth a cada segundo. Para desativar este comportamento de regeneração, adicione um script de saúde vazio chamado Script ao Personagem de iniciante .

Exibição de Barra de Saúde

Quando Health é menor que MaxHealth, uma barra de saúde é exibida na experiência. O comportamento de exibição da barra de saúde depende do Class.Humanoid.HealthDisplayDistance|HealthDis

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

Morte

Quando o valor da saúde do personagem atinge 0, o Humanoid transfere automaticamente para o estado Enum.HumanoidStateType.Dead. Neste estado, Health está bloqueado para 0; no entanto, não há erro ou aviso para definir o 2>Class.Humanoid

Essa propriedade é um número usado em conjunto com a propriedade DisplayDistanceType para controlar a distância a partir da qual a barra de saúde de um humanóide pode ser vista.

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

Esta propriedade controla quando a barra de saúde de um humanóide é permitida para ser exibida. Por padrão, esta propriedade é definida como Class.Humanoid.Health|

Nota que esta propriedade funciona independentemente do espaço de propriedade HealthDisplayDistance que é responsável por fazer a barra de saúde desaparecer em certas distâncias. Se Humanoid.HealthDisplayType|HealthDisplayType for definido como En

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

Determina a distância (em studs) do chão que o RootPart deve estar quando o humanóide está em pé. O RigType afeta a maneira como essa propriedade se comporta.

Para R15 modelos, uma altura de pé adequada é predefinida para garantir a altura do RootPart está correto. A altura das pernas não é usada. A altura geral do humanóide pode ser descrito na seguinte fórmula:

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

Para R6 modelos, HipHeight em vez de descrever um deslocamento relativo. A altura geral do humanóide pode ser descrito na seguinte fórmula:

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

Se true , os saltos de Humanoid com uma força de Humanoid.JumpPower ou a altura de 1> Class.Humanoid.JumpHeight1>, dependendo do valor de 4> Class.Humanoid.UseJumpPower4>, são ajustados para o valor atual de 7>Class.Humanoid.

Fornece controle sobre os saltos de altura de um Humanoid pulo, em studs. O valor inicial desta propriedade é determinado pelo valor de StarterPlayer.CharacterJumpHeight que padrão é 7.2.

Embora definir essa propriedade para 0 impedirá efetivamente o salto do humanoide, recomenda-se desativar o salto desativando o estado Enum.HumanoidStateType.Jumping através de Humanoid:SetStateEnabled() .

Essa propriedade só é visível na <a href="https://www.clarinet.com/pt/propriedades/">janela Propriedades</a>, se <a href="https://www.clarinet.com/pt/propriedades/">Class.Humanoid.UseJumpPower\ estiver definido como <a href="https://www.clarinet.com/pt/propriedades/">falso\, pois não seria relevante de outra forma (em vez disso, <a href="https://www.clarinet.com/pt/propriedades/

Determina a força de subida aplicada ao Humanoid quando você salta. O valor inicial desta propriedade é determinado pelo valor de StarterPlayer.CharacterJumpPower que é padrão 50 e está limitado entre 0 e 1000. Observe que os saltos também são afetados pela propriedade Class.Workspace.Gravity

Embora definir essa propriedade para 0 impedirá efetivamente o salto do humanoide, recomenda-se desativar o salto desativando o estado Enum.HumanoidStateType.Jumping através de Humanoid:SetStateEnabled() .

Essa propriedade só é visível na <a href="https://www.clarinet.com/pt/propriedades/">janela Propriedades</a>, se <a href="https://www.clarinet.com/pt/propriedades/">Class.Humanoid.UseJumpPower\ estiver definido como <a href="https://www.clarinet.com/pt/propriedades/">verdade\, pois de outra forma (em vez disso, <a href="https://www.clarinet.com/pt/propriedades/">Class.

O valor máximo de um humanoide's Health .

O valor desta propriedade é usado ao lado da propriedade Health para dimensionar o display de barra de saúde padrão. Quando uma propriedade Health atinge MaxHealth, sua barra de saúde pode não ser exibida, dependendo de sua propriedade

Essa propriedade determina o ângulo máximo que um humanoide pode escalada. Se o ângulo de um declive for maior que o MaxSlopeAngle de um humanoide, eles deslizarão para baixo do declive.

Quando um personagem é gerado, esta propriedade é definida de acordo com o valor de StarterPlayer.CharacterMaxSlopeAngle.

O valor desta propriedade é restrito a valores entre 0° e 89°. Ele padrão para 89°, para que os humanóides possam escalar quase qualquer declive que eles desejam por padrão.

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

h.MaxSlopeAngle = 30

MoveDirection é uma propriedade de leitura que descreve a direção em que um Humanoid está caminhando, como um vetor de unidade ou um vetor de comprimento zero. A direção é descrita no espaço do mundo.

Como essa propriedade é de leitura apenas, ela não pode ser definida por um Script ou LocalScript.

local RunService = game:GetService("RunService")

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

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

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

RunService.RenderStepped:Connect(updateBobbleEffect)

A propriedade NomeDisplayDistance é um número usado em conjunto com a propriedade Humanoid.DisplayDistanceType para controlar a distância a partir da qual o nome de um humanóide pode ser visto.

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

Controla se a barra de nome e saúde de um humanoide pode ser visto atrás de paredes ou outros objetos. Esta propriedade é um valor Enum.NameOcclusion e pode ser configurado para ocultar todos os nomes, nomes de inimigos ou desativar a ocultação completamente.

Em casos em que o LocalPlayer não tem Class.Humanoid associado, esta propriedade se aplica ao assunto Humanoid.

Veja Nome do Personagem/Exibição de Saúde para uma guia abrangente sobre a aparência dos nomes de personagens e saídas de saúde.

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 se o Humanoid está atualmente no estado Enum.HumanoidStateType.PlatformStanding. Quando verdadeiro, o Humanoid está em um estado onde ele está caindo livre e não pode se movimento. Este estado se comporta semelhante ao de sentar, exceto que o salto não livra o humanoid do estado.

Permite que os desenvolvedores desativem o comportamento onde um jogador Character|character morre se o Neck Motor6D for removido ou desconectado mesmo por um momento. Essa propriedade padrão é definida como verdadeiro.

RigType descreve se um Humanoid está usando o modelo de personagem R6 herdado ou o mais recente rig / plataforma / equipamentode personagem R15.

O R6 usa 6 Parts visíveis enquanto o R15 usa 15 Parts visíveis. Os R15 têm mais juntas do que R6, tornando-os muito mais versáteis ao serem animados.

Nota que se esta propriedade for definida incorretamente, o Humanoid não funcionará corretamente. Por exemplo, se o RigType de um humanóide R15 estiver definido como R6, o Humanoid morrerá, pois não

Uma referência ao Objeto HumanoidRootPart do humanóide, a parte de raiz que controla o movimento do humanóide através do mundo 3D. Essa parte normalmente não é visível.

Nota que, no caso de personagens de jogador, RootPart é o mesmo que o Model.PrimaryPart do modelo Player.Character.

SeatPart é uma referência ao assento que um Humanoid está sentado no momento, se houver. O valor desta propriedade pode ser qualquer Seat ou VehicleSeat. It will be 1> nil1> if o Humanoid não estiver sentado em um assento.

Nota:

• Para um bool descrito se o Humanoid está sentado ou não, veja Humanoid.Sit

A propriedade Sit é umBooleano que indica se o Humanoid está sentado atualmente. Humanoids pode ser forçado a um estado de sentado definindo o valor desta propriedade para true. Se o Humanoid não for anexado a um assento enquanto est

Nota:

• O Seat ou VehicleSeat sentado em que Humanoid está sentado pode ser obtido usando a propriedade 2>Class.Humanoid.SeatPart2>
• É possível detectar quando um Humanoid senta conectando-se ao evento Humanoid.Seated.

Não use Essa propriedade só funciona com o Modo Experimental ativado, que foi descontinuado totalmente.

Esta propriedade descreve uma posição 3D no espaço onde o Player controlando este Humanoid último clicou com um Tool equipado.

Essa propriedade é usada principalmente por ferramentas clássicas para determinar o que um humanoide está alvo quando eles ativam uma ferramenta. Se você der um lançador de foguetes clássico a um NPC, definir seu ponto de alvo e, em seguida, chamar a função Tool:Activate() da ferramenta, você pode fazer o NPC ativar um foguete no ponto de alvo.

Quando um personagem é gerado, esta propriedade é definida de acordo com o valor de StarterPlayer.CharacterUseJumpPower que padrão é verdadeiro.

Ao pular, com este set para verdadeiro, o valor Humanoid.JumpHeight é usado para garantir que os saltos humanóidem para essa altura. Com este set para falso, o valor Humanoid.JumpPower é usado para aplicar uma força para cima.

Essa propriedade descreve o quão rápido o Humanoid é capaz de andar, em studs por segundo. Ele padrão para o valor de StarterPlayer.CharacterWalkSpeed (16), o que significa que um personagem de jogador pode mover 16 studs em qualquer direção a cada segundo.

Notas

• Quando controlado em um dispositivo móvel ou em um controle / controle de jogo, um humanóide pode caminhar mais lentamente que seu WalkSpeed se o thumbstick de controle for movido apenas um grau gradual a partir do centro.
• Você pode congelar um humanoide em seu lugar ao definir WalkSpeed para 0; isso impede que o jogador controlador mova-o através dos mecanismos de movimento padrão.
• O script de animação padrão escala as animações de movimento de um humano com base em quão rápido ele está se movendo em relação à velocidade padrão de 16 studs/ segundo.
• A velocidade em que o Humanoid está atualmente andando pode ser obtida usando o evento Running.

WalkToPart é uma referência a uma parte que o Humanoid está tentando alcançar. Essa propriedade é normalmente definida quando uma parte é passada como o segundo argumento da função Humanoid:MoveTo() do Humanoid.

Quando WalkToPart é definido e um humanoide está tentando ativamente alcançar a peça, ele continuará atualizando seu objetivo Vector3 para ser a posição da peça, plus o Humanoid.WalkToPoint traduzido no espaço de objeto relativo à rotação da peça.

Isso pode ser descrito em Lua como:

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

Cavernas

• Configurar o valor de WalkToPart não é suficiente para fazer um início humanoide após uma peça.
• O Humanoide é solicitado a começar a tentar alcançar um objetivo quando o valor de WalkToPoint for alterado.
• Isso pode ser alterado no futuro.
• O estado de alcance o objetivo de um humanóide expira após 8 segundos se não atingir seu objetivo.
• Isso é feito para que os NPCs não fiquem presos esperando por Humanoid.MoveToFinished para Iniciar / executar.
• Se você não quiser que isso aconteça, você deve repetidamente chamar MoveTo para que o tempo limite seja redefinido.

WalkToPoint descreve a posição 3D no espaço que um humanoide está tentando alcançar, depois de ter sido solicitado a fazer isso pela função Humanoid:MoveTo() do humanoide.

Se o Humanoid.WalkToPart de um humanóide estiver configurar, o objetivo é definido transformando WalkToPoint relativo à posição e rotação das peças. Se WalkToPart não for configurar, então o humanóide tentará alcançar a posição 3D especificada por WalkToPoint diretamente.

Cavernas

• O valor de WalkToPoint deve ser alterado para um valor diferente para que o humanoide comece a caminhar até ele.
• Se você quiser fazer um caminhada humanoide para 0,0,0 , você deve usar a função MoveTo do Humanoid.
• Isso pode ser alterado no futuro.
• O estado de alcance o objetivo de um humanóide expira após 8 segundos se não atingir seu objetivo.
• Isso é feito para que os NPCs não fiquem presos esperando por Humanoid.MoveToFinished para Iniciar / executar.
• Se você não quiser que isso aconteça, você deve repetidamente chamar MoveTo para que o tempo limite seja redefinido.

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 ataca o Accessory especificado ao pai do hiperoid.

Quando este método é chamado, um Accessory é anexado ao personagem ao procurar um

Se o requerido Attachment não puder ser encontrado, então o Accessory permanecerá ligado ao pai do hidrôide, mas não será desprendido.

Normalmente, soldaduras de acessórios são criadas no servidor, mas elas podem ser criadas no cliente sob certas condições. Nessas situações, chamadas do lado do cliente para AddAccessory() podem não sempre produzir o comportamento desejado e você pode usar Class.Humanoid:BuildRigFromAttachments()|BuildRigFromAttachments

Parâmetros

Devolução

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 monta uma árvore de Motor6D juntas para o Humanoid . Motor6D juntas são necessárias para o playback de 1> Class.Animation|Animações1> .

Começando a partir do RootPart do humanoide, este método coleta todos os Attachments pais na parte atual cujo nome termina com R

Humanoid:BuildRigFromAttachments() também escala o personagem e configura as cores do corpo.

Devolução

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

Essa função causa o Humanoid entrar no dado Enum.HumanoidStateType, descrevendo a atividade que o Humanoid está fazendo.

Por favor, revise a página Enum.HumanoidStateType para mais informações sobre os estados, como alguns têm nomes não intuitivos. Por exemplo, Enum.HumanoidStateType.Running descreve um estado onde as pernas do humanóide estão no chão, incluindo quando estacionário.

Devido ao comportamento padrão do Humanoid, alguns estados serão alterados automaticamente quando configurar. Por exemplo:

• Configurar o estado para Enum.HumanoidStateType.Swimming quando o humanóide não estiver na água fará com que ele seja definido automaticamente para Enum.HumanoidStateType.GettingUp .
• Como não está sendo usado, definir o estado para Enum.HumanoidStateType.PlatformStanding fará com que o estado humanoide seja definido automaticamente para Enum.HumanoidStateType.Running.

Veja também Humanoid:SetStateEnabled() para ativar ou desativar um estado específico, e Humanoid:GetState() para obter o estado atual do humanóide.

Parâmetros

Devolução

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)

Essa função faz com que o Humanoid equipe o Tool dado.

O exemplo abaixo causaria um Player para equipar uma ferramenta em Workspace chamada 'Tool'.

local Players = game:GetService("Players")

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

Quando essa função for chamada, o humanóide automaticamente desequipar qualquer Tools que já estiver equipado

Embora eles sejam equipados, Tools para os quais Tool.RequiresHandle é, true não funcionará se eles não tiverem Manipulador / alça, independentemente de usar ou não esta função para equipá-los

Veja também:

• Para desequipar ferramentas, use Humanoid:UnequipTools()

Parâmetros

Devolução

Essa função retorna um array de Accessory objetos que o pai do humanoide está usando atualmente. Todos esses objetos Accessory serão incluídos, independentemente de serem anexados ou não.

Se o Humanoid não tiver objetos Accessory, um array vazio será retornado.

Veja também Humanoid:AddAccessory() para adicionar um Accessory ao pai de um humanóide.

Devolução

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)

Essa função retorna uma cópia do cache do humanóide HumanoidDescription que descreve seu visual atual. Isso pode ser usado para determinar rapidamente o visual de um personagem e atribuir seu visual a outros personagens usando a função Humanoid:ApplyDescription().

Veja também

• Players:GetHumanoidDescriptionFromUserId() que retorna um HumanoidDescription descrevendo o avatar para o usuário passado.
• Players:GetHumanoidDescriptionFromOutfitId() que retorna um HumanoidDescription cujos parâmetros são inicializados para corresponder ao que está no recurso de moda do lado do servidor.
• Player:LoadCharacterWithHumanoidDescription() que gera um jogador com a aparência daquele que passou em HumanoidDescription.

Devolução

Essa função retorna o que Enum.BodyPartR15 ou Part é, ou Enum.BodyPartR15.Unknown se a parte não for uma parte do corpo R15. Essa função permite que os desenvolvedores recuperem partes do corpo do jogador independentemente do que sejam os nomes reais das peças do corpo, em vez de retornar um enum.

Pode ser usado em conjunto com Humanoid:ReplaceBodyPartR15() . Por exemplo, se uma parte do corpo de um jogador tocar algo, esta função retornará get a part instância. Os desenvolvedores podem então olhar para qual parte do corpo que estava, como cabeça ou braço. Depois, dependendo de qual parte foi, os desenvolvedores podem executar alguma ação de jogo ou substituir essa parte com alguma outra parte - tal

Essa função pode ser útil para jogos onde a localização do hit é importante. Por exemplo, pode ser usado para determinar se um jogador foi hit na perna e depois desacelerá-lo com base na lesão.

Parâmetros

Devolução

Essa função retorna o Enum.Limb 枚úmero que é associado com o Part dado. Funciona para ambos os modelos R15 e R6, por exemplo:

-- Para R15
print(humanoid:GetLimb(character.LeftUpperLeg))  -- Entrada.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftLowerLeg))  -- Entrada.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftFoot))  -- Entrada.Limb.LeftLeg

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

Nota que Humanoid:GetLimb() vai throw um erro se a parte's parent não for definido para o pai do humanoid.

Parâmetros

Devolução

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

Devolução

Essa função retorna o atual Enum.HumanoidStateType do humanóide, descrevendo a atividade que o Humanoid está fazendo, como pular ou nadar.

Veja também Humanoid:SetStateEnabled() para ativar ou desativar um estado específico, e Humanoid:ChangeState() para alterar o estado atual do humanóide.

Devolução

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)

A função GetStateEnabled retorna se um Enum.HumanoidStateType está ativado para o Humanoid.

O estado humanoide descreve a atividade que o humanoide está executando atualmente.

Quando um determinado Enum.HumanoidStateType é desativado, o humanóide nunca pode entrar nesse estado. Isso é verdade, independentemente de tentar alterar o estado usando Humanoid:ChangeState() ou código humano interno do Roblox.

Veja também:

• Para um evento que ocorre quando um estado de humanóide é ativado ou desativado, veja Humanoid.StateEnabledChanged
• Para ativar ou desativar um estado Humanoid use Humanoid:SetStateEnabled()

Parâmetros

Devolução

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

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

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

Essa função faz com que o Humanoid ande na direção dada Vector3.

Por padrão, a direção é em termos de mundo, mas se o parâmetro relativeToCamera for true, a direção será relativa à direção do CFrame da 2>Class.Workspace.CurrentCamera|CurrentCamera2>.

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

Quando essa função é chamada, o Humanoid irá se mover até que a função seja chamada novamente. No entanto, se os scripts de controle padrão estiverem sendo usados, essa função será sobrescrita quando chamada no jogador Characters. Isso pode ser evitado ao não usar os scripts de controle padrão ou ao chamar ess

Essa função pode ser chamada no servidor, mas isso só deve ser feito quando o servidor tiver propriedade de rede da montagem do humanóide.

Veja também Humanoid:MoveTo() , que faz um Humanoid caminhar até um ponto, e Player:Move() , que chama essa função de forma efetiva.

Parâmetros

Devolução

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)

Essa função causa o Humanoid para tentar caminhar para o local dado, definindo as propriedades Humanoid.WalkToPoint e Humanoid.WalkToPart.

Os parâmetros Class.Humanoid.WalkToPoint e Class.Humanoid.WalkToPart correspondem aos que serão definidos Humanoid.WalkToPoint e 2>Class.Humanoid.WalkToPart2>.

Se o parâmetro parte for especificado, o Humanoid ainda tentará caminhar até o ponto. No entanto, se o parte se mover, o ponto Humanoid que está caminhando para ser na mesma posição 2>relativa à parte2>

O estado de chegar ao objetivo de um humanóide será expirado após 8 segundos se ele não alcançar seu objetivo. Isso é feito para que os NPCs não fiquem presos esperando por Humanoid.MoveToFinished para Iniciar / executar. Se você não quiser que isso aconteça, você deve repetidamente chamar MoveTo para que o tempo limite seja redefinido.

MoveTo() termina se uma das seguintes condições se aplicar:

• O personagem chega ao seu destino.

• O personagem fica preso e o timer de oito segundos expira.

• O valor de Humanoid.WalkToPoint ou Humanoid.WalkToPart muda.

• Um script chama Humanoid:Move() com um novo parâmetro moveDirection.

• Um script altera a propriedade CFrame do RootPart.

Parâmetros

Devolução

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)

Essa função remove todos os objetos Accessory usados pelo pai do humanóide. Para o jogador Characters, isso removerá todos os chapéus e outros acessórios.

Essa função remove o objeto Accessory por chamar Instance:Destroy() em seus, o que significa que o Parent dos acessórios está definido como 2>nil2> e bloqueado.

Veja também Humanoid:AddAccessory() para anexar um Accessory e Humanoid:GetAccessories() para obter todos os objetos 1> Class.Accessory1> pertencentes a um 4> Class.Humanoid4>.

Devolução

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)

Substitui dinamicamente uma peça de membro R15/Rthro em um Humanoide com uma peça diferente. A peça é escalada automaticamente como normal.

Essa função é útil para modificar personagens durante o jogo ou construir personagens a partir de uma base de rig / plataforma / equipamento. A função relacionada GetBodyPartR15 pode ser útil ao usar essa função.

O nome da peça deve corresponder ao nome da BodyPartR15 Enum passada.

Parâmetros

Devolução

Essa função define se um Enum.HumanoidStateType específico está ativado para o Humanoid. Quando um Enum.HumanoidStateType é desativado, o 1> Class.Humanoid1>

Nota que usar SetStateEnabled() no servidor não replica a alteração para o cliente, nem vice-versa.

Parâmetros

Devolução

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)

Essa função reduz o Humanoid.Health do Humanoid pelo valor dado quanto se não for protegido por um 1> Class.ForceField1>

Essa função aceita valores negativos para o parâmetro quanto. Isso aumentará o Humanoid.Health do humanóide. No entanto, isso só terá um efeito se nenhum ForceField estiver presente.

Como ForceBlocks protege contra TakeDamage

Um Humanoid é considerado protegido por um ForceField se um ForceField atende a um dos seguintes critérios:

• O ForceField compartilha o mesmo Instance.Parent que o Humanoid
• O ForceField está ligado ao Humanoid.RootPart do Humanoid
• O ForceField está ligado a um ancestral do Humanoid outro que não o Workspace

Para causar dano a um Humanoid irrespective of any ForceFields present, set Humanoid.Health directly.

Para mais informações sobre como ForceFields protege Humanoids veja a página ForceField

Parâmetros

Devolução

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)

Essa função desequipa qualquer Tool atualmente equipado pelo Humanoid

O desequipado Tool será ligado à Backpack do Player associado com o 1> Class.Humanoid1>.

Se nenhum Tool estiver equipado, esta função não fará nada.

Embora Tools possa ser equipado por NPCs (Não Jogadores), esta função só funciona em Humanoids com um correspondente Player . Isso é porque um objeto 2> Class.Backpack2> é necessário para paisar o 5> Class.Tool5> desequipado

Veja também:

• Para equipar um Tool em vez disso, use Humanoid:EquipTool()

Devolução

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)

Essa função de retorno faz com que o personagem pareça ser correspondente ao que o passado em HumanoidDescription . Uma cópia do passado HumanoidDescription é armazenada como o HumanoidDescription para o 1> Class.Human .

Essa função é otimizada ao fazer a suposição de que apenas essa função é usada para alterar a aparência do personagem e nenhuma alteração é feita através de outros meios entre chamadas. Se alterações forem feitas ao personagem entre chamadas. Então essa função pode não refletir o personagem de forma precisa.

Veja também

• Humanoid:GetAppliedDescription() que retorna o HumanoidDescription atualmente aplicado ao humanóide.
• Players:GetHumanoidDescriptionFromUserId() que retorna um HumanoidDescription descrevendo o avatar para o usuário passado.
• Players:GetHumanoidDescriptionFromOutfitId() que retorna um HumanoidDescription cujos parâmetros são inicializados para corresponder ao que está no recurso de moda do lado do servidor.
• Player:LoadCharacterWithHumanoidDescription() que gera um jogador com a aparência daquele que passou em HumanoidDescription.

Parâmetros

Devolução

Essa função de retorno faz com que o personagem pareça ser correspondente ao que o passado em HumanoidDescription, mesmo depois de alterações externas. Uma cópia do passado HumanoidDescription é armazenada como o HumanoidDescription para o 1> Class.Humanoid .

Essa função sempre garantirá que o personagem reflita o que foi passado em Class.Human

Parâmetros

Devolução