Humanoid

AutoJumpEnabled imposta se o no il Humanoid cercherà di saltare automaticamente sopra un ostacolo che sta camminando verso.

Attualmente, questa proprietà funziona solo quando sono vere le seguenti condizioni:

• Il modello di personaggio dell'Humanoid è il Player.Character di un Player .
• Il giocatore in questione sta usando Controllitouch.

Quando il personaggio di un Giocatoreviene generato, il valore della Proprietàcorrisponde alla proprietà del GiocatorePlayer.AutoJumpEnabled - che a sua volta corrisponde alla proprietà StarterPlayer.AutoJumpEnabled.

local Players = game:GetService("Players")

local player = Players.LocalPlayer
local button = script.Parent

local function update()
	-- Update button text
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Reflect the property in the player's character, if they have one
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Toggle auto-jump
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Update everything else
	update()
end

button.Activated:Connect(onActivated)
update()

La proprietà AutoRotate descrive se l'Humanoid ruoterà automaticamente verso l'avanti nella direzione in cui si muove. Quando impostato su true, il modello di personaggio si trasformerà gradualmente verso la loro direzione di movimento mentre l'Humanoid cammina intorno. Quando impostato su false, il modello di personaggio rimarrà fissato nella sua attuale rotazione, a meno che una forza di rotazione non sia applicata alla parte della radice dell'Humanoid.

Se il modello del personaggio è quello di un Giocatore, allora il comportamento della rotazione dell'umanoid è influenzato dalla ProprietàRotateType di UserGameSettings.

Quando la proprietà AutoRotate è impostata su true, la proprietà RotateType ha i seguenti effetti sulla rotazione dell'Humanoid:

<tbody>
  <tr>
    <td>Relazione di movimento</td>

    <td />

    <td />
  </tr>

  <tr>
    <td>Relativo alla fotocamera</td>
    <td>Il personaggio ruoterà verso l'avanti nella direzione della Telecamera.</td>
    <td>Il giocatore ha la telecamera zoomata in prima persona, o è in modalità shift-lock.</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

Il Humanoid ha sei valori di escala per bambini tra cui BodyDepthScale , BodyHeightScale , BodyProportionScale , 2> BodyTypeScale2> , 5> HeadScale5> . La modifica di uno qualsiasi di questi

Determina se le articolazioni dell'umanoid si rompono quando nell' stato Enum.HumanoidStateType.Dead . Le predefinite sono vere.

La proprietà CameraOffset specifica un offset alla posizione della Telecameraquando la sua Camera.CameraSubject è impostata su questa Humanoid .

L'Offset viene applicato nell'area dell'oggetto, rispetto all'orientamento del HumanoidRootPart dell'Humanoide. Ad esempio, un valore di Vector3 di (0, 10, 0) offre lo spostamento della fotocamera del Giocatoredi 10 studs sopra l'Humanoide.

local RunService = game:GetService("RunService")

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

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

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

RunService.RenderStepped:Connect(updateBobbleEffect)

La proprietà DisplayDistanceType controlla il comportamento della distanza del nome e della salute del personaggio. Questa proprietà viene impostata utilizzando il Enum.HumanoidDisplayDistanceType enum con tre valori disponibili, ognuno con un insieme di regole proprie:

• Quando impostato su Viewer, l'umanoid vede il nome/la salute di altri umanoidi nella sua stessa NameDisplayDistance e HealthDisplayDistance .
• Quando impostato su Subject, il manichino prende il controllo completo del proprio nome e della sua salute attraverso i suoi valori NameDisplayDistance e NameDisplayDistance.
• Quando impostato su None, la barra del nome e della salute del humanoid non appare sotto nessuna condizione.

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

local humanoid = script.Parent

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

DisplayName è una proprietà che determina la visualizzazione del nome dell'uomoide quando è visibile. Per impostazione predefinita, un nuovo uomoide avrà il valore di una Stringavuota. Se DisplayName è una Stringavuota, la visualizzazione del nome dell'uomoide prenderà il valore della Proprietàdi un uomoide parent.

Caricamento personaggio giocatore

Quando i giocatori caricano il loro personaggio, automaticamente o attraverso l'uso di LoadCharacter(), l'Umanoide che viene creato dal motore avrà la sua proprietà DisplayName impostata sulla ProprietàDisplayName del Giocatore.

StarterCharacter e StarterHumanoid

Quando un Humanoid chiamato StarterHumanoid è parented a StarterPlayer ,

Questa è una proprietà di lettura che descrive il Enum.Material che si trova attualmente sopra. Funziona con sia i normali Humanoid e Parts voxel.

L'esempio di codice seguente mostra come ascoltare quando questa proprietà cambia usando Object:GetPropertyChangedSignal() . Quando il materiale su cui si trova l'umanoid è cambiato, stamperà un messaggio che indica il nuovo materiale su cui si trova.

local Humanoid = route.to.humanoid

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

Grotte

• Quando il Humanoid non è in piedi su un pavimento, il valore di questa proprietà sarà impostato su Air.

  • Questo si verifica porque le proprietà di Enum non possono avere un valore vuoto.
  • Questo può causare alcune confusioni se un parte ha il suo materiale impostato su Air, anche se in pratica le parti non dovrebbero usare quel materiale in primo Posto.
• Il modello di personaggio del Humanoid deve essere in grado di collisionare con il pavimento, altrimenti non sarà rilevato.

  • Non puoi testare se il Humanoid nuota con questa Proprietà. Dovresti invece utilizzare la sua funzione Humanoid:GetState().

Questa proprietà rappresenta la salute attuale del Humanoid. Il valore è limitato alla gamma tra 0 e MaxHealth. Se il humanoid è morto, questa proprietà viene impostata in modo continuativo su 0.

Nota che la funzione TakeDamage() può essere utilizzata per sottrarre da Health invece di impostare la proprietà direttamente.

Rigenerazione della salute

Per impostazione predefinita, uno script di rigenerazione della salute passiva viene inserito automaticamente in humanoid. Ciò causa che i personaggi non morti MaxHealth ogni secondo. Per disabilitare questo comportamento di rigenerazione, aggiungi un vuoto Script chiamato Salute a 1> Class.StarterCharacterScripts</

Visualizzazione della barra della salute

Quando Health è inferiore a MaxHealth, viene visualizzata una barra di salute nell'esperienza. Il comportamento della barra di salute è dipendente dal HealthDisplayDistance e 1> Class.Humanoid.HealthDisplayType|HealthDisplayType

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

Morte

Quando il valore della salute del personaggio raggiunge 0, il Humanoid passa automaticamente allo stato Enum.HumanoidStateType.Dead. In questo stato, Health è bloccato a 0; tuttavia, non ci sono errori o avvertimenti per impostare il 2>Class.H

Questa proprietà è un numero utilizzato in conjunction con la proprietà DisplayDistanceType per controllare la distanza dalla quale la barra della salute di un umano può essere vista.

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

Questa proprietà controlla quando la barra della salute di un umanoide può essere visualizzata. Per impostazione predefinita, questa proprietà è impostata su Class.Humanoid.Health

Nota che questa proprietà funziona indipendentemente dalla proprietà HealthDisplayDistance che è responsabile di fare sparire la barra della salute a certi livelli. Se Humanoid.HealthDisplayType|HealthDisplayType è impostato su Enum.HumanoidHealthDisplayType|

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

Determina la distanza (in studs) dal terreno il RootPart che dovrebbe essere quando il humanoid è in piedi. Il RigType influenza il modo in cui si comporta questa proprietà.

Per le navi R15, una altezza di gamba appropriata è preimpostata per garantire l'altezza della RootPart è corretta. L'altezza delle gambe non è utilizzata. L'altezza generale del umanoid può essere descritta nella seguente formula:

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

Per le navi R6, HipHeight invece descrive un Dislocamentorelativo. L'altezza totale dell'umanoid può essere descritta nella seguente formula:

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

Se true , i salti Humanoid con una forza pari al valore di Humanoid.JumpPower o l'altezza di 2>Class.Humanoid.JumpHeight2>, a seconda del valore di 5>Class.Humanoid.UseJumpPower5> .

Fornisce controllo sulla altezza di un Humanoid salti, in studs. Il valore iniziale di questa proprietà è determinato dal valore di StarterPlayer.CharacterJumpHeight che predefinito è 7.2.

Anche se impostare questa proprietà su 0 prevenirà efficacemente il salto dell'umanoide, è consigliato disabilitare il salto disabilitando lo stato Enum.HumanoidStateType.Jumping attraverso Humanoid:SetStateEnabled() .

Questa proprietà è visibile solo nella finestra Proprietà se Humanoid.UseJumpPower è impostato su falso, poiché non sarebbe rilevante altrimenti (invece, 2>Class.Humanoid.JumpPower2> viene utilizzato).

Determina la forza di spinta verso l'alto applicata al Humanoid quando si salta. Il valore iniziale di questa proprietà è determinato dal valore di StarterPlayer.CharacterJumpPower che predefinito è 50 e è limitato tra 0 e 1000. Nota che i salti sono anche influenzati dalla proprietà Class

Anche se impostare questa proprietà su 0 prevenirà efficacemente il salto dell'umanoide, è consigliato disabilitare il salto disabilitando lo stato Enum.HumanoidStateType.Jumping attraverso Humanoid:SetStateEnabled() .

Questa proprietà è visibile solo nella finestra Proprietà se Humanoid.UseJumpPower è impostato su vero , poiché non sarebbe rilevante altrimenti (invece, 2>Class.Humanoid.JumpHeight2> viene utilizzato).

Il valore massimo di un Health umanoid.

Il valore di questa proprietà viene utilizzato insieme alla proprietà Health per ridimensionare la visualizzazione della barra della salute predefinita. Quando una barra della salute di un Health raggiunge, la sua barra della salute potrebbe non essere visualizzata, a seconda della sua Proprietà

Questa proprietà determina l'angolo di declinazione massimo che un umanoide può scalata. Se l'angolo di un declinazione è maggiore di un umanoide's MaxSlopeAngle, scivoleranno verso il basso dal declinazione.

Quando un personaggio viene generato, questa proprietà viene impostata in base al valore di StarterPlayer.CharacterMaxSlopeAngle .

Il valore di questa proprietà è limitato ai valori tra 0 ° e 89 °. Si prefigge di 89 °, quindi gli umanoidi possono salire quasi qualsiasi pendenza che vogliono per impostazione predefinita.

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

h.MaxSlopeAngle = 30

MoveDirection è una proprietà di proprietà di lettura che descrive la direzione in cui si muove un Humanoid , come un veicolo di unità o un vettorialedi lunghezza zero. La direzione è descritta nello Spaziodel mondo.

Poiché questa proprietà è di sola lettura, non può essere impostata da un Script o LocalScript .

local RunService = game:GetService("RunService")

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

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

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

RunService.RenderStepped:Connect(updateBobbleEffect)

La proprietà NameDisplayDistance è un numero utilizzato in conjunction con la proprietà Humanoid.DisplayDistanceType per controllare la distanza dalla quale il nome di un umano può essere visto.

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

Controlla se la barra del nome e della salute di un umanoide può essere vista dietro i muri o altri oggetti. Questa proprietà è un valore Enum.NameOcclusion e può essere configurata per occludere tutti i nomi, i nomi nemici o disabilitare completamente l'occlusione.

In casi in cui il LocalPlayer non ha Humanoid associato, questa proprietà si applica invece al soggetto Humanoid .

Vedi Nome del personaggio/Visualizzazione della salute per una guida in dettaglio sui controlli dell'aspetto dei nomi dei personaggi e delle barre di salute.

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 il Humanoid è attualmente nello stato Enum.HumanoidStateType.PlatformStanding . Quando è vero, l'Humanoid è in uno stato in cui è libero cadere e non può Sposta. Questo stato si comporta simile alla seduta, tranne che il salto non libera l'Humanoid dallo stato.

Consente ai sviluppatori di disabilitare il comportamento in cui un giocatore Character|character muore se il Neck Motor6D viene rimosso o disconnesso anche solo per un momento. Questa proprietà predefinita è impostata su true.

RigType descrive se un Humanoid sta utilizzando il vecchio R6 character Piattaforma di test, o il nuovo R15 character Piattaforma di test.

Il R6 utilizza 6 Class.Part|Part visibili mentre il R15 utilizza 15 Class.Part|Part visibili. I R15 hanno più articolazioni rispetto ai R6, rendendoli molto più versatili quando vengono animati.

Nota che se questa proprietà è impostata in modo errato, la Humanoid non funzionerà correttamente. Ad esempio, se il RigType di un R15 è impostato su R6, il Humanoid morirà poich

Un riferimento all'oggetto HumanoidRootPart del Humanoid che controlla il movimento di un umano attraverso il Mondo3D. Questa parte è normalmente invisibile.

Nota che nel caso dei personaggi del giocatore, RootPart è lo stesso che il Model.PrimaryPart del modello Player.Character.

SeatPart è un riferimento alla seduta in cui un Humanoid sta attualmente seduto, se presente. Il valore di questa proprietà può essere qualsiasi Seat , o VehicleSeat . Sarà 1> zero1> se l'Humanoid non si trova attualmente in una seduta.

Nota:

• Per un bool che indica se il Humanoid è attualmente in sedi o no, vedi Humanoid.Sit

La proprietà Sit è un booletten che indica se il Humanoid sta attualmente seduto. Humanoids può essere forzato in uno stato di seduta impostando il valore di questa Proprietàsu true. Se il Humanoid non è attacc

Nota:

• Il Seat o VehicleSeat il Humanoid che si trova su può essere ottenuto utilizzando la Proprietà1> Class.Humanoid.SeatPart1>
• È possibile rilevare quando un Umanoide si siede connesso all'evento Humanoid.Seated .

Non usare Questa proprietà funziona solo con la modalità sperimentale abilitata, che è stata completamente discontinuata.

Questa proprietà descrive una posizione 3D nello spazio in cui il Player che controlla questo Humanoid l'ultimo cliccato con un Tool equipaggiato.

Questa proprietà viene principalmente utilizzata da strumenti classici per determinare cosa un umanoide sta mirando quando attiva uno strumento. Se dai a un NPC un lanciatore di razzi classico, imposta il loro TargetPoint , quindi chiami la funzione Tool:Activate() dello strumento, puoi far sparare un razzo al punto di destinazione.

Quando un personaggio viene generato, questa proprietà viene impostata in base al valore di StarterPlayer.CharacterUseJumpPower che predefinito è vero.

Quando si salta, con questo set a vero, il valore Humanoid.JumpHeight viene utilizzato per garantire i salti dell'uomo a quella Humanoid.JumpPower altezza. Con questo set a falso, il valore Class.Humanoid.JumpPower viene utilizzato per applicare una forza di spinta verso l'alto.

Questa proprietà descrive quanto rapidamente il Humanoid è in grado di Camminata, in studs per secondo. Predefinito il valore di StarterPlayer.CharacterWalkSpeed (16), il che significa che un personaggio del giocatore può muoversi in 16 studs in qualsiasi direzione ogni secondo.

Note

• Quando viene controllato su un dispositivo mobile o su una gamepad, un umanoide può camminare più lentamente del suo WalkSpeed se il joystick di controllo viene spostato solo di un grado di gradiente dal centro.
• Puoi congelare un umanoide in posizione impostando WalkSpeed a 0; questo impedisce al giocatore di controllare di muoverlo attraverso i meccanismi di movimento predefiniti.
• Lo script di animazione predefinito scala le animazioni di movimento di un umano in base alla velocità relativa di 16 studs/secondo.
• La velocità con cui Humanoid cammina attualmente può essere ottenuta utilizzando l'evento Running .

WalkToPart è un riferimento a una parte che l'Humanoid sta cercando di raggiungere. Questa proprietà viene impostata normalmente quando una parte viene passata come argomento 2 della funzione Humanoid:MoveTo() dell'Humanoid.

Quando WalkToPart è impostato e un umanoide sta attivamente cercando di raggiungere la parte, continuerà ad aggiornare il suo obiettivo Vector3 per essere la posizione della parte, plus il Humanoid.WalkToPoint tradotto nello spazio di oggetto rispetto alla rotazione della parte.

Questo può essere descrittivo in Lua come:

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

Grotte

• Impostare il valore di WalkToPart non è abbastanza per fare un inizio umanoidale dopo una parte.
• L'Umanoide viene richiesto di iniziare a cercare di raggiungere un obiettivo quando il valore di WalkToPoint viene cambiato.
• Potrebbe essere cambiato in futuro.
• Lo stato raggiungere il obiettivo di un umanoide scade dopo 8 secondi se non raggiunge il suo obiettivo.
• Questo è fatto in modo che i NPC non si blocchino aspettando Humanoid.MoveToFinished per Lanciare.
• Se non vuoi che questo accada, dovresti chiamare ripetutamente MoveTo in modo che il timer rimanga impostato.

WalkToPoint descrive la posizione 3D nello spazio che un umanoide sta cercando di raggiungere, dopo essere stato invitato a farlo dalla funzione Humanoid:MoveTo() dell'uomoide.

Se è ImpostareHumanoid.WalkToPart di un umanoide, il obiettivo è impostato trasformando WalkToPoint relativo alla posizione e alla rotazione delle parti. Se WalkToPart non è Impostare, allora il umanoide cercherà di raggiungere la posizione 3D specificata da WalkToPoint direttamente.

Grotte

• Il valore di WalkToPoint deve essere cambiato in un valore diverso in modo che l'uomoide inizi a camminare verso di esso.
• Se vuoi fare un'umanoidi 0,0,0 0,0,0 , devi usare la funzione MoveTo dell'umanoid.
• Potrebbe essere cambiato in futuro.
• Lo stato raggiungere il obiettivo di un umanoide scade dopo 8 secondi se non raggiunge il suo obiettivo.
• Questo è fatto in modo che i NPC non si blocchino aspettando Humanoid.MoveToFinished per Lanciare.
• Se non vuoi che questo accada, dovresti chiamare ripetutamente MoveTo in modo che il timer rimanga impostato.

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)

Questo metodo attacca il Accessory specificato al parentdell'umanoid.

Quando questo metodo viene chiamato, un Accessory viene attaccato al personaggio cercando un Class

Se il richiesto Attachment non può essere trovato, allora il Accessory rimarrà affidato al padre dell'umanoido ma non sarà disattaccato.

Tipicamente, le saldature di accessori vengono Creazionisul Server, ma possono essere create sul client sotto alcune condizioni. In queste situazioni, le chiamate client-side a AddAccessory() possono non sempre produrre il comportamento desiderato e puoi usare BuildRigFromAttachments() per forzare

Parametri

Restituzioni

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)

Questo metodo assembla un albero di Motor6D giunture per il Humanoid . Motor6D giunte sono richieste per il riproduzione di 1> Class.Animation|Animazioni1> .

A partire dall'humanoide's RootPart , questo metodo raccoglie tutti i Attachments genitori nella parte attuale la cui fine con Rig

Humanoid:BuildRigFromAttachments() scala anche il personaggio e imposta i colori del corpo.

Restituzioni

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

Questa funzione fa in modo che il Humanoid entri nel dato Enum.HumanoidStateType, che descrive l'attività che il Humanoid sta attualmente eseguendo.

Per favore, Enum.HumanoidStateType la pagina per ulteriori informazioni sui singoli stati, poiché alcuni hanno nomi non intuitivi. Ad esempio, Enum.HumanoidStateType.Running descrive uno stato in cui le gambe dell'umanoid sono sul terreno, tra cui quando sono inattive.

A causa del comportamento predefinito del Class.Humanoid , alcuni stati verranno automaticamente modificati quando Impostare. Ad esempio:

• Impostare lo stato su Enum.HumanoidStateType.Swimming quando lo humanoid non è in acqua causerà che venga automaticamente impostato su Enum.HumanoidStateType.GettingUp .
• Poiché non è in uso, impostare lo stato su Enum.HumanoidStateType.PlatformStanding farà in modo che lo stato umano sia impostato automaticamente su Enum.HumanoidStateType.Running .

Vedi anche Humanoid:SetStateEnabled() per abilitare o disabilitare uno stato specifico, e Humanoid:GetState() per ottenere lo stato attuale del robot umanoid.

Parametri

Restituzioni

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)

Questa funzione fa in modo che il Humanoid equipaggi il Tool dato.

L'esempio seguente causerebbe un Player per equipaggiare uno strumento in Workspace chiamato '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 questa funzione viene chiamata, l'humanoide si disequipaggia automaticamente qualsiasi Tools che ha attualmente equipaggiato

Anche se saranno equipaggiati, Tools per cui Tool.RequiresHandle non funzionerà se non hanno una gestire, indipendentemente dal fatto che questa funzione sia utilizzata per equipaggiarli o no

Vedi anche:

• Per disequipaggiare gli strumenti, usa Humanoid:UnequipTools()

Parametri

Restituzioni

Questa funzione restituisce un array di Accessory oggetti che il genitore dell'umanoido indossa attualmente. Tutti questi oggetti Accessory saranno inclusi, indipendentemente dal fatto che siano attaccati o no.

Se il Humanoid non ha oggetti Accessory, un'arraya vuota verrà restituita.

Vedi anche Humanoid:AddAccessory() per attaccare un Accessory al parentdi un umanoide.

Restituzioni

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)

Questa funzione restituisce una copia del cache di Class.Humanoid HumanoidDescription che descrive il suo aspetto attuale. Questo può essere utilizzato per determinare rapidamente l'aspetto di un personaggio e assegnare il loro aspetto ad altri personaggi utilizzando la funzione Humanoid:ApplyDescription() .

Vedi anche

• Players:GetHumanoidDescriptionFromUserId() che restituisce un HumanoidDescription che descrive l'avatar per l'utente passato.
• Players:GetHumanoidDescriptionFromOutfitId() che restituisce un HumanoidDescription il cui parametro inizializza per corrispondere a quello dell'outfit lato server.
• Player:LoadCharacterWithHumanoidDescription() che genera un giocatore con l'aspetto dal passato in HumanoidDescription .

Restituzioni

Questa funzione restituisce ciò che Enum.BodyPartR15 è, o Part se la parte non è una parte del corpo R15. Questa funzione consente ai sviluppatori di recuperare parti del corpo del giocatore indipendentemente dal fatto che i nomi delle parti del corpo siano o meno una parte del corpo R15. Questa funzione consente ai sviluppatori di recuperare parti del corpo del giocatore indipendentemente dal fatto che i nomi

Può essere utilizzato in conjunction con Class.Humanoid:ReplaceBodyPartR15() ). Ad esempio, se una parte del corpo di un Giocatoretocca qualcosa, questa funzione restituirà get a part instance. Gli sviluppatori possono quindi guardare up what part of the body that was, come head o arm. Quindi a seconda di ciò che è stata, gli sviluppatori possono eseguire alcune azioni di gioco o sostituire quella parte con un'altra parte - for

Questa funzione può essere utile per i giochi in cui la posizione dell'hit è importante. Ad esempio, può essere utilizzato per determinare se un giocatore è stato colpito in gamba e poi rallentarli in base all'infortunio.

Parametri

Restituzioni

Questa funzione restituisce l'Enum.Limb枚 che è associato con il Part in uso. Funziona per entrambi i rig R15 e R6, ad esempio:

-- Per R15
print(humanoid:GetLimb(character.LeftUpperLeg))  -- Enum.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftLowerLeg))  -- Enum.Limb.LeftLeg
print(humanoid:GetLimb(character.LeftFoot))  -- Enum.Limb.LeftLeg

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

Nota che Humanoid:GetLimb() lancerà un errore se il padre della parte non è impostato sul parentdel humanoid.

Parametri

Restituzioni

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

Restituzioni

Questa funzione restituisce il valore corrente dell'umanoid Enum.HumanoidStateType, che descrive l'attività che il Humanoid sta attualmente eseguendo, come il salto o la nuotazione.

Vedi anche Humanoid:SetStateEnabled() per abilitare o disabilitare uno stato specifico, e Humanoid:ChangeState() per cambiare lo stato attuale del humanoid.

Restituzioni

local UserInputService = game:GetService("UserInputService")
local character = script.Parent

local humanoid = character:WaitForChild("Humanoid")

local doubleJumpEnabled = false

humanoid.StateChanged:Connect(function(_oldState, newState)
	if newState == Enum.HumanoidStateType.Jumping then
		if not doubleJumpEnabled then
			task.wait(0.2)
			if humanoid:GetState() == Enum.HumanoidStateType.Freefall then
				doubleJumpEnabled = true
			end
		end
	elseif newState == Enum.HumanoidStateType.Landed then
		doubleJumpEnabled = false
	end
end)

UserInputService.InputBegan:Connect(function(inputObject)
	if inputObject.KeyCode == Enum.KeyCode.Space then
		if doubleJumpEnabled then
			if humanoid:GetState() ~= Enum.HumanoidStateType.Jumping then
				humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
				task.spawn(function()
					doubleJumpEnabled = false
				end)
			end
		end
	end
end)

La funzione GetStateEnabled restituisce se un Enum.HumanoidStateType è abilitato per il Humanoid .

Lo stato umanoidale descrive l'attività che lo umanoidale sta attualmente eseguendo.

Quando un particolare Enum.HumanoidStateType è disabilitato, l'uomoide non può mai entrare in tale stato. Questo è vero indipendentemente dal fatto che l'attentato a cambiare stato sia eseguito utilizzando Humanoid:ChangeState() o il codice umanoidale interno Roblox.

Vedi anche:

• For an event that fires when a humanoid state is enabled or disabled see Humanoid.StateEnabledChanged
• Per abilitare o disabilitare uno stato Humanoid usa Humanoid:SetStateEnabled()

Parametri

Restituzioni

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

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

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

Questa funzione fa in modo che il Humanoid cammini nella direzione Vector3 specificata.

Per impostazione predefinita, la direzione è in Condizionimondiali, ma se il parametro relativeToCamera è true, la direzione è relativa alla CFrame del 2>Class.Area di lavoro.CurrentCamera|CurrentCamera2> . Come la direzione

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

Quando questa funzione viene chiamata, il Humanoid si muoverà fino a quando la funzione non sarà chiamata di nuovo. Tuttavia, se gli script di controllo predefiniti sono in uso, questa funzione sarà sovrascritta quando chiamata su player Characters . Ciò può essere evitato utilizzando uno qualsiasi degli script di controllo pre

Questa funzione può essere chiamata sul Server, ma questo dovrebbe essere fatto solo quando il server ha proprietà di rete della raccolta di humanoid.

Vedi anche Humanoid:MoveTo() che rende un Humanoid camminare verso un punto, e Player:Move() che effettivamente chiama questa funzione.

Parametri

Restituzioni

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)

Questa funzione fa in modo che il Humanoid tenti di camminare verso la posizione specificata impostando le proprietà Humanoid.WalkToPoint e Humanoid.WalkToPart.

I parametri luogo e parte corrispondono a ciò che Humanoid.WalkToPoint e 1> Class.Humanoid.WalkToPart1> saranno impostati.

Se il parametro parte è specificato, il Humanoid cercherà comunque di camminare al punto. Tuttavia, se la parte si muove, il punto Humanoid che cammina sarà per muoversi in posizione relativa alla parte 2> . Se il param

Lo stato raggiungere il obiettivo di un umanoide si esaurisce dopo 8 secondi se non raggiunge il suo obiettivo. Questo è fatto in modo che i NPC non si blocchi aspettando per Humanoid.MoveToFinished per l'Lanciare. Se non vuoi che questo accada, devi ripetutamente chiamare MoveTo in modo che il timer si resettino.

MoveTo() finisce se una delle seguenti condizioni si applica:

• Il personaggio arriva alla sua destinazione.

• Il personaggio viene bloccato e il timer di otto secondi scade.

• Il valore di Humanoid.WalkToPoint o Humanoid.WalkToPart cambia.

• Un script chiama Humanoid:Move() con un nuovo parametro moveDirection .

• uno script cambia la proprietà CFrame di RootPart .

Parametri

Restituzioni

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)

Questa funzione rimuove tutti Accessory oggetti indossati dalla parentdel giocatore. Per il giocatore Characters , questo rimuoverà tutti i cappelli e altri accessori.

Questa funzione rimuove l'oggetto Accessory da essi chiamando Instance:Destroy() su di loro, il che significa che il Parent degli accessori è impostato su 2>nil2> e bloccato.

Vedi anche Humanoid:AddAccessory() per aggiungere un Accessory e Humanoid:GetAccessories() per ottenere tutti gli oggetti 1> Class.Accessory1> che appartengono a un 4> Class.Humanoid4> .

Restituzioni

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)

Rimpiazza dinamicamente una parte del limbo R15 / Rthro in un Umanoide con una parte diversa. La parte viene scala automaticamente come normale.

Questa funzione è utile per modificare i personaggi durante il gameplay o costruire personaggi da una base Piattaforma di test. La funzione relativa GetBodyPartR15 può essere utile quando si utilizza questa funzione.

Il nome della parte superata dovrebbe corrispondere con il nome della BodyPartR15 Enum superata.

Parametri

Restituzioni

Questa funzione imposta se un particolare Enum.HumanoidStateType è abilitato per il Humanoid . Quando un particolare Enum.HumanoidStateType è disabilitato, il 1> Class.Humanoid1>

Nota che l'uso di SetStateEnabled() sul server non replica il cambiamento al client, né viceversa.

Parametri

Restituzioni

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)

Questa funzione abbassa il Humanoid.Health del Humanoid dal valore number se non è protetto da un 2>Class.ForceField2>

Questa funzione accetta valori negativi per il valore parametro. Ciò aumenterà il Humanoid.Health . Tuttavia, questo avrà solo un effetto se non è presente ForceField.

Come ForceFields protegge contro TakeDamage

Un Humanoid è considerato protetto da un ForceField se un ForceField soddisfa uno dei seguenti criteri:

• Il ForceField condivide lo stesso Instance.Parent del Humanoid
• Il ForceField è parented to the Humanoid.RootPart of the Humanoid
• Il ForceField è affidato a un antenato del Humanoid altro che il Workspace

Per fare danno a un Humanoid irrespective of any ForceFields present, set Humanoid.Health directly.

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

Parametri

Restituzioni

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)

Questa funzione disequipaggia qualsiasi Tool attualmente equipaggiato dal Humanoid

Il Tool non equipaggiato sarà affidato al Backpack di Class.Player associato al Player .

Se non Tool è equipaggiato, questa funzione non farà nulla.

Anche se Tools può essere equipaggiato da NPC (non giocatori), questa funzione funziona solo su Humanoids con un corrispondente Player . Ciò è dovuto al fatto che un oggetto 1> Class.Backpack1> richiede per essere genitore del

Vedi anche:

• Per equipaggiare invece un Tool , usa Humanoid:EquipTool()

Restituzioni

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)