Humanoid

O AutoJumpEnabled define se o Humanoid vai tentar pular automaticamente por um obstáculo que ele está caminhando.

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

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

Quando o 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()
	-- Atualizar texto do botão
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Reflete a propriedade no personagem do jogador, se ele tiver uma
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Alternar pulo automático
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Atualize tudo o mais
	update()
end

button.Activated:Connect(onActivated)
update()

A propriedade Girar Automaticamente descreve se o Humanoide girará automaticamente para a direção em que estiver se movendo.Quando definido como verdadeiro, o modelo de personagem irá gradualmente virar para a direção de movimento deles à medida que o Humanoide caminha ao redor.Quando definido como falso, o modelo de personagem permanecerá fixado em sua rotação atual, a menos que uma força rotativa seja aplicada ao HumanoidRootPart.

Se o modelo de personagem for o personagem de um jogador, então o comportamento da rotação do Humanoide é influenciado pela propriedade RotateType do UserGameSetting.

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

<th>Comporte</th>

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

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

    <td />

    <td />
  </tr>

  <tr>
    <td>CameraRelativa</td>

    <td>O personagem girará para frente na direção da Câmera.</td>

    <td>O jogador tem sua câmera ampliada 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 infantil, incluindo BodyDepthScale, BodyHeightScale, BodyProportionScale, BodyTypeScale, BodyWidthScale, HeadScale.Mudar o valor de qualquer uma dessas causas faz com que as partes do corpo e acessórios do personagem mudem de tamanho, mas apenas se AutomaticScalingEnabled for verdadeiro.

Determina se as articulações do humanoide quebram quando no estado Enum.HumanoidStateType.Dead . Padrão para verdadeiro.

A propriedade CameraOffset especifica um deslocamento para a posição do assunto da Câmeraquando seu Camera.CameraSubject é definido para esta Humanoid.

O deslocamento é aplicado no espaço do objeto, em relação à orientação da parte raiz do Humanoide HumanoidRootPart.Por exemplo, um valor de deslocamento Vector3 de (0, 10, 0) desloca a câmera do jogador para 10 metros acima do humanoide do jogador.

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 Distância de ExibiçãoTipo controla o comportamento de distância da exibição do nome e da saúde do humanoide.Essa propriedade é definida usando o Enum.HumanoidDisplayDistanceType com três valores disponíveis, cada um com seu próprio conjunto de regras:

• Quando definido para Viewer , o humanoide vê o nome/saúde de outros humanóides dentro do alcance de seu próprio NameDisplayDistance e HealthDisplayDistance .
• Quando definido para , o humanoide toma controle total sobre seu próprio nome e exibição de saúde através de seus valores e .
• Quando definido para None, o nome e a barra de saúde do humanoide não aparecem em nenhuma circunstância.

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras 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 do nome do Humanoide quando visível.Por padrão, um novo Humanoide terá o valor de uma string / cadeia / textovazia.Se DisplayName for uma string / cadeia / textovazia, a exibição do nome do humanoide padrãoizará a propriedade do nome do pai do humanoide.

Carregamento de Personagem de Jogador

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

Personagem Inicial e StarterHumanoid

Quando um Humanoid chamado StarterHumanoid é pai de StarterPlayer , ou quando um Humanoide está presente em um Modelo chamado StarterCharacter , a propriedade DisplayName será respeitada quando os Personagens forem carregados por Jogadores no jogo.O motor só substituirá a propriedade DisplayName da Humanoid com a propriedade DisplayName da jogadora se a Humanoid.DisplayName de StarterHumanoid for uma string / cadeia / textovazia.

Esta é uma propriedade de leitura apenas que descreve o Enum.Material o Humanoid está atualmente em pé.Funciona com ambos os voxels regulares Parts e Terrain regulares.

O exemplo de código abaixo mostra como ouvir quando essa propriedade muda usando Object:GetPropertyChangedSignal().Quando o material em que o humanoide está pousado muda, ele imprimirá uma mensagem indicando o novo material em que está pousado.

local Humanoid = route.to.humanoid

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

Ressalvas

• Quando o Humanoid não está em um piso, o valor dessa propriedade será definido como Ar.

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

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

Essa propriedade representa a saúde atual do Humanoid.O valor é restrito ao intervalo entre 0 e MaxHealth .Se o humanoide estiver morto, esta propriedade é continuamente definida como 0.

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

Regeneração de Saúde

Por padrão, um script de regeneração de saúde passiva é automaticamente inserido em humanóides.Isso faz com que os personagens não mortos do jogador se regenerem 1% de cada segundo.Para desabilitar esse comportamento de regeneração, adicione um vazio Script chamado Saúde a StarterCharacterScripts.

Exibição da 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 HealthDisplayDistance e HealthDisplayType.

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras 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 Health de um humanoide morto para um valor positivo não zero.

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 humanoide pode ser vista.

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras de saúde.

Essa propriedade controla quando a barra de saúde de um humanoide é permitida ser exibida.Por padrão, esta propriedade é definida como DisplayWhenDamaged, o que faz com que a barra de saúde seja exibida apenas quando a Health de um humanoide for menor que sua MaxHealth.Também pode ser definido para AlwaysOn , o que faz com que a barra de saúde sempre seja exibida ou AlwaysOff , o que impede que ela seja exibida.

Observe que essa propriedade funciona independentemente da propriedade do humanoide HealthDisplayDistance que é responsável por fazer a barra de saúde desaparecer em determinadas distâncias.Se Humanoid.HealthDisplayType|HealthDisplayType for definido para AlwaysOn, ainda desaparecerá dependendo de como HealthDisplayDistance for configurado.

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras de saúde.

Determina a distância (em studs) fora do chão que o RootPart deve estar quando o humanoide está de pé.O RigType influencia a maneira como essa propriedade se comporta.

Para equipamentos R15, uma altura de quadril adequada é predefinida para garantir que a altura do RootPart seja correta.A altura das pernas não é usada.A altura geral do humanoide pode ser descrita na seguinte fórmula:

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

Para rigs R6, HipHeight em vez disso descreve um deslocamento relativo. A altura geral do humanoide pode ser descrita na seguinte fórmula:

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

Se true , o Humanoid saltos com uma força para cima igual ao valor de Humanoid.JumpPower ou a altura de Humanoid.JumpHeight , dependendo do valor de Humanoid.UseJumpPower .

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

Embora definir esta propriedade para 0 efetivamente impeça o humanoide de pular, é recomendado desativar o pulo desativando o estado Enum.HumanoidStateType.Jumping através de Humanoid:SetStateEnabled().

Essa propriedade só é visível na janela Propriedades se Humanoid.UseJumpPower estiver definida como falsa , pois não seria relevante de outra forma (em vez disso, Humanoid.JumpPower é usado).

Determina quanta força de cima é aplicada ao Humanoid ao pular.O valor inicial desta propriedade é determinado pelo valor de StarterPlayer.CharacterJumpPower que padrão é 50 e está restrito entre 0 e 1000.Observe que os saltos também são influenciados pela propriedade Workspace.Gravity que determina a aceleração devido à gravidade.

Embora definir esta propriedade para 0 efetivamente impeça o humanoide de pular, é recomendado desativar o pulo desativando o estado Enum.HumanoidStateType.Jumping através de Humanoid:SetStateEnabled().

Essa propriedade só é visível na janela Propriedades se Humanoid.UseJumpPower estiver definida como verdadeira , pois não seria relevante de outra forma (em vez disso, Humanoid.JumpHeight é usado).

O valor máximo de um humanoide Health .

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

Essa propriedade determina o ângulo máximo de inclinação que um humanoide pode escalada.Se o ângulo de um declive for maior que o ângulo máximo de um hidroide, eles deslizarão pelo declive.

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

O valor desta propriedade é limitado a valores entre 0° e 89°.Ele padrãoiza para 89°, então humanóides podem escalar praticamente qualquer declive que desejem por padrão.

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

h.MaxSlopeAngle = 30

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

Como essa propriedade é apenas de leitura, 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 Distância de Exibição do Nome é um número usado em conjunto com a propriedade Humanoid.DisplayDistanceType para controlar a distância a partir da qual o nome de um humanoide pode ser visto.

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras de saúde.

Controla se o nome e a barra de vida de um humanoide podem ser vistos atrás de paredes ou outros objetos.Essa propriedade é um valor Enum.NameOcclusion e pode ser configurada para ocultar todos os nomes, nomes inimigos ou desativar completamente a ocultação.

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

Veja Nome/Saúde do Personagem para um guia detalhado sobre como controlar a aparência de nomes de personagens e barras 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 Humanoide está em um estado em que está caindo livremente e não pode se movimento.Este estado se comporta de forma semelhante a sentar-se, exceto que pular não libera o humanoide do estado.

Permite que os desenvolvedores desabilitem o comportamento onde um jogador morre se o Pescoço for removido ou desconectado mesmo por um momento.Essa propriedade padrão é verdadeira.

RigType descreve se um Humanoid está utilizando o legado R6 personagem rig / plataforma / equipamento, ou o personagem R15 mais novo.

O equipamento R6 usa 6 visíveis Parts enquanto o equipamento R15 usa 15 visíveis Parts .R15 equipamentos têm mais articulações do que equipamentos R6, tornando-os muito mais versáteis ao serem animados.

Observe que se esta propriedade for definida incorretamente, o Humanoid não funcionará corretamente.Por exemplo, se o Tipo de Rig de um humanoide R15 for definido como R6, o Humanoid morrerá pois não há BasePart chamado Torso conectado a um BasePart chamado Cabeça .

Uma referência ao Objeto Raiz Humanoide do Humanoide do humanoide, a parte de condução da raiz do Humanoid que controla o movimento de um humanoide através do mundo 3D.Essa parte é normalmente invisível.

Para personagens R15, Model.PrimaryPart do modelo Player.Character é definido como Raiz Humanoide .

Para personagens R6, Model.PrimaryPart é definido para a parte Head.

A Parte de Assento é uma referência ao assento em que um Humanoid está sentado no momento, se algum.O valor desta propriedade pode ser um Seat ou um VehicleSeat.Será nil se o Humanoide não estiver sentado em um assento no momento.

Nota:

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

A propriedade Sit é um booleano que indica se o Humanoid está sentado atualmente.Humanoids pode ser forçado a um estado sentado ao definir o valor desta propriedade para verdadeiro.Se o Humanoid não estiver anexado a um assento enquanto estiver em seu estado sentado, ele tropeçará sem colisão em suas pernas.Um Humanoid pode escapar do estado sentado pulando.

Nota:

• O Seat ou VehicleSeat o Humanoid está sentado em pode ser obtido usando a propriedade Humanoid.SeatPart
• É possível detectar quando um Humanoide se senta conectando-se ao evento Humanoid.Seated.

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

Essa propriedade descreve uma posição 3D no espaço onde o Player controla este Humanoid último clicado com um Tool equipado.

Essa propriedade é principalmente usada por ferramentas clássicas para determinar o que um humanoide está almejando quando ativa uma ferramenta.Se você der a um NPC um lançador de foguetes clássico, defina seu Ponto de Alvo , e então chame a função Tool:Activate(), você pode fazer o NPC disparar 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 saltar, com este valor definido como verdadeiro, o valor Humanoid.JumpHeight é usado para garantir que os saltos humanóides para essa altura.Com isso definido como falso, o valor Humanoid.JumpPower é usado para aplicar uma força ascendente.

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

Notas

• Quando controlado em um dispositivo móvel ou em um controle / controle de jogo, um humanoide pode caminhar mais devagar do que seu WalkSpeed se o polegar de controle for movido apenas um grau gradual do centro.
• Você pode congelar um humanoide no lugar definindo WalkSpeed para 0; isso impede que o jogador controlador o mova através dos mecanismos de movimento padrão.
• O script de animação padrão escala as animações de movimento de um humanoide com base na velocidade com que está se movendo em relação à velocidade padrão de 16 studs/segundo.
• A velocidade em que o Humanoid está caminhando no momento 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 Humanoide.

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

Isso pode ser descrito em Luau como:

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

Ressalvas

• Definir o valor de WalkToPart não é suficiente para fazer um humanoide começar a seguir uma parte.
• 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 alcançar o objetivo do robô humano expirará após 8 segundos se não alcançar seu objetivo.
• Isso é feito para que NPCs não fiquem presos esperando Humanoid.MoveToFinished para Iniciar / executar.
• Se você não quiser que isso aconteça, você deve chamar repetidamente MoveTo para que o tempo limite continue sendo reiniciado.

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

Se o Humanoid.WalkToPart de um humanoide for configurar, o objetivo é definido transformando WalkToPoint em relação à posição e rotação das peças.Se WalkToPart não for configurar, o humanoide tentará chegar à posição 3D especificada por WalkToPoint diretamente.

Ressalvas

• O valor de WalkToPoint deve ser alterado para um valor diferente para que o humanoide comece a caminhar até ele.
• Se você quiser fazer uma caminhada humanoide para 0,0,0 , você deve usar a função MoveTo do Humanoide.
• Isso pode ser alterado no futuro.
• O estado de alcançar o objetivo do robô humano expirará após 8 segundos se não alcançar seu objetivo.
• Isso é feito para que NPCs não fiquem presos esperando Humanoid.MoveToFinished para Iniciar / executar.
• Se você não quiser que isso aconteça, você deve chamar repetidamente MoveTo para que o tempo limite continue sendo reiniciado.

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 anexa o especificado Accessory ao pai do humanoide.

Quando este método é chamado, um é anexado ao personagem ao procurar por um em o pai do humanoide que compartilha o mesmo nome de um no acessório Handle .Se um for encontrado, a parte Mão será conectada ao pai do Attachment usando um Weld, e a solda será configurada para que o Attachments ocupe o mesmo espaço.

Se o necessário Attachment não puder ser encontrado, então o Accessory permanecerá ligado ao pai do humanoide, mas não estará anexado.

Normalmente, soldas acessórias são criadas no servidor, mas podem ser criadas no cliente em determinadas circunstâncias.Nessas situações, chamadas do lado do cliente para AddAccessory() podem nem sempre produzir o comportamento desejado e você pode usar BuildRigFromAttachments() para forçar a criaçõesde solda esperada.

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 a reprodução de Animations .

Começando com o humanoide's RootPart , este método coleta todos os Attachments pais na parte atual cujo nome termina com RigAttachment .Então, ele procura um anexo correspondente no personagem que compartilha o mesmo nome do anexo.Usando esses dois anexos, uma junta Motor6D é gerada com base nas peças associadas aos dois anexos e na CFrame das peças dos anexos.

Humanoid:BuildRigFromAttachments() também escala o personagem e define 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

Este método faz com que o Humanoid entre no Enum.HumanoidStateType dado, descrevendo a atividade que o Humanoid está fazendo no momento.

Por favor, revise a página Enum.HumanoidStateType para obter mais informações sobre os estados particulares, pois alguns têm nomes intuitivos.Por exemplo, Enum.HumanoidStateType.Running descreve um estado em que as pernas do humanoide estão no chão, incluindo quando estão paradas.

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

• Definir o estado para Enum.HumanoidStateType.Swimming quando o humanoide não está na água fará com que ele seja automaticamente definido como Enum.HumanoidStateType.GettingUp.
• Como não está sendo usado, definir o estado para Enum.HumanoidStateType.PlatformStanding causará o estado humanoide ser definido automaticamente para Enum.HumanoidStateType.Running .

Observe que, para definir o estado Humanoid usando esse método, você deve fazê-lo a partir de um LocalScript e o cliente deve ter propriedade de rede do Player.Character.Alternativamente, você pode chamar esse método de um lado do servidor Script , mas o servidor deve ter propriedade de rede do personagem do jogador.

Veja também Humanoid:SetStateEnabled() para habilitar ou desabilitar um estado específico, e Humanoid:GetState() para obter o estado humanoide atual.

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)

Este método faz com que o Humanoid equipe o dado Tool.

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

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

Quando este método é chamado, o Humanoid primeiro vai desequipar automaticamente todos os Tools que ele atualmente tem equipados.

Embora eles sejam equipados, Tools para o qual Tool.RequiresHandle é verdadeiro não funcionará se não tiverem Manipulador / alça, independentemente se este método for usado para equipá-los ou não.

Veja também:

• Para desequipar ferramentas, use Humanoid:UnequipTools()

Parâmetros

Devolução

Este método retorna um conjunto de Accessory objetos que o pai do humanoide está usando no momento.Todos esses objetos Accessory serão incluídos, independentemente de estarem anexados ou não.

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

Veja também Humanoid:AddAccessory() para anexar um Accessory a um pai de um humanoide.

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)

Este método retorna uma cópia do cache do humanoide HumanoidDescription que descreve sua aparência atual.Isso pode ser usado para determinar rapidamente o visual de um personagem e atribuir seu visual a outros personagens usando o método 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 da entidade de roupa passada no lado do servidor.
• Player:LoadCharacterWithHumanoidDescription() que gera um jogador com o visual do passado em HumanoidDescription .

Devolução

Este método retorna o que Enum.BodyPartR15 um Part é, ou Enum.BodyPartR15.Unknown se a peça não for uma parte do corpo R15.Este método permite que os desenvolvedores recuperem partes do corpo do jogador independentemente do que são os nomes das partes do corpo reais, retornando um enum.

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

Este método pode ser útil para jogos onde a localização do golpe é importante.Por exemplo, pode ser usado para determinar se um jogador foi atingido na perna e, em seguida, desacelerá-lo com base na lesão.

Parâmetros

Devolução

Este método retorna o Enum.Limb enum que está associado ao dado Part. Ele funciona para ambas as plataformas R15 e R6, por exemplo:

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

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

Observe que Humanoid:GetLimb() vai lançar um erro se o pai da peça não for definido como o pai do humanoide.

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

Este método retorna o atual Enum.HumanoidStateType do humanoide, descrevendo a atividade que o Humanoid está fazendo no momento, como pular ou nadar.

Veja também Humanoid:SetStateEnabled() para habilitar ou desabilitar um estado específico, e Humanoid:ChangeState() para alterar o estado humanoide atual.

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)

O método GetStateEnabled retorna se um Enum.HumanoidStateType está habilitado para o Humanoid.

O estado humanoide descreve a atividade que o humanoide está fazendo no momento.

Quando um determinado Enum.HumanoidStateType é desativado, o humanoide nunca pode entrar nesse estado.Isso é verdade independentemente se a tentativa de alterar o estado for feita usando Humanoid:ChangeState() ou código humanoide interno do Roblox.

Veja também:

• Para um evento que dispara quando um estado humanoide é ativado ou desativado, veja Humanoid.StateEnabledChanged
• Para habilitar ou desabilitar um estado de Humanoid usar 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

Este método faz com que o Humanoid caminhe na direção dada Vector3.

Por padrão, a direção está em termos mundiais, mas se o parâmetro relativeToCamera for true, a direção é relativa ao CFrame do CurrentCamera.Como a direção negativa Z negativa é considerada "para frente" no Roblox, o seguinte código fará a caminhada humanoide na direção do CurrentCamera.

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

Quando este método é chamado, o Humanoid se moverá até que o método seja chamado novamente.No entanto, esse método será substituído na próxima frame pelo script de controle de personagem padrão do Roblox.Isso pode ser evitado chamando essa função a cada quadro usando RunService:BindToRenderStep() (veja exemplo), ou substituindo os scripts de controle em StarterPlayerScripts .

Este método pode ser chamado no servidor, mas isso só deve ser feito quando o servidor tiver propriedade de rede da montagem do humanoide.

Veja também Humanoid:MoveTo() que faz um Humanoid caminhada para um ponto, e Player:Move() que chama efetivamente essa função.

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)

Este método causa o Humanoid para tentar caminhar para o local dado definindo as propriedades Humanoid.WalkToPoint e Humanoid.WalkToPart.

Os parâmetros de localização e peça correspondem ao que e serão definidos.

Se o parâmetro parte for especificado, o Humanoid ainda tentará caminhar até o ponto.No entanto, se a peça se mover, então o ponto Humanoid que está caminhando para será movido para a mesma posição em relação à peça .Se o parâmetro parte não for especificado, então a posição para a qual a Humanoid não mudará.

O estado de alcançar o objetivo do robô humano expirará após 8 segundos se não alcançar seu objetivo.Isso é feito para que NPCs não fiquem presos esperando Humanoid.MoveToFinished para Iniciar / executar.Se você não quiser que isso aconteça, você deve chamar repetidamente MoveTo para que o tempo limite continue sendo reiniciado.

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

• O personagem chega ao seu destino. Existe um limite de ~1 stud para contabilizar várias velocidades e taxas de quadros humanóides.

• O personagem fica preso e o cronômetro de oito segundos expira.

• O valor de qualquer 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)

Este método remove todos os Accessory objetos usados pelo pai do humanoide. Para o jogador Characters, isso removerá todos os chapéus e outros acessórios.

Este método remove o objeto Accessory por chamar Instance:Destroy() sobre eles, significando que o Parent dos acessórios está definido como nil e bloqueado.

Veja também Humanoid:AddAccessory() para anexar um Accessory e Humanoid:GetAccessories() para obter todos os objetos Accessory pertencentes a um Humanoid .

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 parte de membro R15/Rthro em um Humanoide por uma parte diferente. A parte é automaticamente escalada como normal.

Este método é útil para modificar personagens durante o jogo ou construir personagens a partir de um rig / plataforma / equipamentobase.O método relacionado GetBodyPartR15 pode ser útil ao usar este método.

O nome da peça passada deve coincidir com o nome da BodyPartR15 Enum passada.

Parâmetros

Devolução

Este método define se um determinado Enum.HumanoidStateType é habilitado para o Humanoid.Quando um determinado Enum.HumanoidStateType é desativado, o Humanoid nunca pode entrar nesse estado.Isso é verdade independentemente se a tentativa de alterar o estado for feita usando Humanoid:ChangeState() ou código interno do Roblox Humanoid.

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

Este método reduz o do pelo valor dado se não for protegido por um

Este método aceita valores negativos para o parâmetro quantidade.Isso aumentará o humanoide de Humanoid.Health.No entanto, isso só terá efeito se não houver ForceField presente.

Como os ForceFields protegem contra Tomar Dano

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

• O ForceField compartilha o mesmo Instance.Parent como o Humanoid
• O ForceField é parente do Humanoid.RootPart do Humanoid
• O ForceField é parente de um ancestral do Humanoid outro que não seja o Workspace

Para causar dano a um Humanoid independentemente de qualquer ForceFields presente, defina Humanoid.Health diretamente.

Para mais informações sobre como ForceFields proteger 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)

Este método desequipa qualquer Tool atualmente equipado pelo Humanoid

O desequipado Tool será pai do Backpack do Player associado ao Humanoid .