Humanoid

AutoJumpEnabled imposta se il Humanoid cercherà di saltare automaticamente su un ostacolo al quale si sta camminando.

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

• Il modello di carattere dell'Umanoide è il Player.Character di un Player.
• Il giocatore in questione sta utilizzando i Controllitouch.

Quando il personaggio di un Giocatoresi genera, 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 o meno l'Humanoid si girerà automaticamente verso la direzione in cui si sta muovendo.Quando è impostato su vero, il modello di personaggio si rivolgerà gradualmente alla direzione del movimento mentre l'Umanoide cammina in giro.Quando è impostato su false, il modello di personaggio rimarrà fisso nella sua rotazione attuale, a meno che una forza rotante non venga applicata al HumanoidRootPart.

Se il modello di personaggio è il personaggio di un Giocatore, allora il comportamento della rotazione dell'Umanoide è influenzato dalla ProprietàRotateType di UserGameSetting.

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

<th>Comportamento</th>

    <th>Contesto</th>
  </tr>
</thead>

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

    <td />

    <td />
  </tr>

  <tr>
    <td>CameraRelativa</td>

    <td>Il personaggio ruoterà per affrontare nella direzione della Telecamera.</td>

    <td>Il giocatore ha la sua fotocamera 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

L'Humanoid ha sei valori di scala per bambini, tra cui BodyDepthScale , BodyHeightScale , BodyProportionScale , BodyTypeScale , BodyWidthScale , HeadScale .Cambiare il valore di una di queste cause fa cambiare le parti del corpo e gli accessori del personaggio, ma solo se AutomaticScalingEnabled è vero.

Determina se le articolazioni dell'umanoide si rompono quando è nello stato Enum.HumanoidStateType.Dead . Predefinito vero.

La proprietà CameraOffset specifica un offset alla posizione soggetto della Telecameraquando il suo Camera.CameraSubject è impostato su questa Humanoid.

L'offset viene applicato nello spazio oggetto, rispetto all'orientamento del Humanoid's HumanoidRootPart .Ad esempio, un valore di offset Vector3(0, 10, 0) compensa la fotocamera del Giocatorea 10 studs sopra l'umanoide del Giocatore.

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 dell'oido umano.Questa proprietà è impostata utilizzando l'enum Enum.HumanoidDisplayDistanceType con tre valori disponibili, ognuno con il proprio set di regole:

• Quando è impostato su Viewer , l'umanoide vede il nome/la salute di altri umanoidi entro il raggio del proprio NameDisplayDistance e HealthDisplayDistance .
• Quando è impostato su Subject , l'umanoide prende pieno controllo sul proprio nome e sulla visualizzazione della salute attraverso i suoi NameDisplayDistance e HealthDisplayDistance valori.
• Quando è impostato su None , il nome e la barra della salute dell'umanoide non appaiono in nessun caso.

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della 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'Umanoide quando è visibile.Per impostazione predefinita, un nuovo Humanoid avrà il valore di una Stringavuota.Se DisplayName è una Stringavuota, la visualizzazione del nome dell'umanoide imposterà la Proprietàdel nome del parentdell'umanoide.

Caricamento del personaggio del giocatore

Quando i giocatori caricano il loro personaggio, sia automaticamente che attraverso l'uso di LoadCharacter() , l'Umanoide creato dall'engine avrà la sua proprietà DisplayName impostata sulla Proprietàdel GiocatoreDisplayName.

Personaggio iniziale e StarterHumanoid

Quando un Humanoid chiamato StarterHumanoid è parented to StarterPlayer , o quando un Umanoide è presente in un Modello chiamato StarterCharacter , la proprietà DisplayName sarà rispettata quando i Personaggi vengono caricati dai Giocatori nel Gioco.Il motore sostituirà solo la proprietà DisplayName della Humanoid con la proprietà DisplayName del giocatore se la Humanoid.DisplayName di StarterHumanoid è una Stringavuota.

Questa è una proprietà read-only che descrive il Enum.Material il Humanoid è attualmente in piedi.Funziona con entrambi i voxel regolari Parts e Terrain e voxel.

L'esempio di codice seguente mostra come ascoltare quando questa proprietà cambia utilizzando Object:GetPropertyChangedSignal() .Quando il materiale su cui si trova l'umanoide cambia, 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)

Avvertenze

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

  • Questo accade perché le proprietà Enum non possono avere un valore vuoto.
  • Questo può causare qualche confusione se una 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 collidere con il pavimento, altrimenti non verrà rilevato.

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

Questa proprietà rappresenta la salute attuale del Humanoid .Il valore è limitato all'intervallo tra 0 e MaxHealth .Se l'umanoide è morto, questa proprietà viene continuamente impostata a 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 negli umanoidi.Questo causa ai personaggi non morti di rigenerare l'1% di MaxHealth ogni secondo.Per disabilitare questo comportamento di rigenerazione, aggiungi un vuoto Script chiamato Salute a StarterCharacterScripts .

Display della barra della salute

Quando Health è inferiore a MaxHealth, viene visualizzata una barra della salute nell'esperienza.Il comportamento di visualizzazione della barra della salute dipende da HealthDisplayDistance e HealthDisplayType.

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della salute.

Morta

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 vi è alcun errore o avviso per impostare il Health di un umanoide morto a un valore positivo non zero.

Questa proprietà è un numero utilizzato in combinazione con la proprietà DisplayDistanceType per controllare la distanza da cui la barra della salute di un umanoide può essere vista.

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della salute.

Questa proprietà controlla quando la barra della salute di un umanoide è consentita di essere visualizzata.Per impostazione predefinita, questa proprietà è impostata su DisplayWhenDamaged , il che fa in modo che la barra della salute venga visualizzata solo quando l'Health di un umanoide è inferiore al suo MaxHealth.Può anche essere impostato su AlwaysOn , che fa in modo che la barra della salute venga sempre visualizzata, o AlwaysOff , che impedisce che venga mai visualizzata.

Si noti che questa proprietà funziona in modo indipendente dalla proprietà dell'umanoide HealthDisplayDistance che è responsabile del fatto che la barra della salute sbiadisce a determinate distanze.Se Humanoid.HealthDisplayType|HealthDisplayType è impostato su AlwaysOn, si attenuerà ancora a seconda di come HealthDisplayDistance è configurato.

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della salute.

Determina la distanza (in studs) dal suolo che il RootPart dovrebbe essere quando l'umanoide sta in piedi.Il RigType influisce sul modo in cui questa proprietà si comporta.

Per i rig R15, un'altezza della coscia adeguata è preimpostata per garantire che l'altezza del RootPart sia corretta.L'altezza delle gambe non viene utilizzata.L'altezza complessiva dell'umanoide può essere descritta nella seguente formula:

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

Per i rig R6, HipHeight invece descrive un Dislocamentorelativo. L'altezza complessiva dell'umanoide può essere descritta nella seguente formula:

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

Se true , il salto Humanoid avviene con una forza verso l'alto uguale al valore di Humanoid.JumpPower o l'altezza di Humanoid.JumpHeight, a seconda del valore di Humanoid.UseJumpPower.

Fornisce il controllo sull'altezza di un salto Humanoid in studs.Il valore iniziale di questa proprietà è determinato dal valore di StarterPlayer.CharacterJumpHeight che predefinisce 7.2.

Anche se impostare questa proprietà a 0 impedirà effettivamente all'umanoide di saltare, è consigliato disabilitare il salto disabilitando lo stato Enum.HumanoidStateType.Jumping attraverso Humanoid:SetStateEnabled() .

Questa proprietà è visibile solo nella finestra Proprietà se Humanoid.UseJumpPower è impostata su falso , altrimenti non sarebbe rilevante (invece, Humanoid.JumpPower viene utilizzato).

Determina quanta forza verso l'alto viene applicata al Humanoid quando si salta.Il valore iniziale di questa proprietà è determinato dal valore di StarterPlayer.CharacterJumpPower che predefinisce 50 e è limitato tra 0 e 1000.Si noti che i salt sono influenzati anche dalla proprietà Workspace.Gravity che determina l'accelerazione dovuta alla gravità.

Anche se impostare questa proprietà a 0 impedirà effettivamente all'umanoide di saltare, è consigliato disabilitare il salto disabilitando lo stato Enum.HumanoidStateType.Jumping attraverso Humanoid:SetStateEnabled() .

Questa proprietà è visibile solo nella finestra Proprietà se Humanoid.UseJumpPower è impostata su vero , altrimenti non sarebbe rilevante (invece, Humanoid.JumpHeight viene utilizzato).

Il valore massimo di un umanoide di Health .

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

Questa proprietà determina l'angolo di pendenza massimo che un umanoide può scalata.Se l'angolo di una pendenza è maggiore dell'angolo massimo di una humanoid, scivoleranno lungo la pendenza.

Quando un personaggio viene generato, questa proprietà viene impostata secondo il valore di StarterPlayer.CharacterMaxSlopeAngle .

Il valore di questa proprietà è limitato ai valori tra 0° e 89°.Predefinisce 89°, quindi gli umanoidi possono salire praticamente 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à read-only che descrive la direzione in cui un Humanoid cammina, come unità vector o vettorialedi lunghezza zero.La direzione è descritta nello Spaziodel mondo.

Poiché questa proprietà è read-only, 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 combinazione con la proprietà Humanoid.DisplayDistanceType per controllare la distanza da cui il nome di un umanoide può essere visto.

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della salute.

Controlla se il nome e la barra della salute di un umanoide possano essere visti dietro le pareti o altri oggetti.Questa proprietà è un valore Enum.NameOcclusion e può essere configurata per includere tutti i nomi, i nomi nemici o disabilitare completamente l'occlusione.

Nei casi in cui il LocalPlayer non ha alcuna Humanoid associata ad esso, questa proprietà si applica invece al soggetto Humanoid .

Vedi Nome del personaggio/visualizzazione della salute per una guida dettagliata su come controllare l'aspetto dei nomi dei personaggi e delle barre della 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 cade liberamente e non può Sposta.Questo stato si comporta in modo simile a sedere, tranne che il salto non libera l'umanoide dallo stato.

Consente agli sviluppatori di disabilitare il comportamento in cui un giocatore Character|character muore se il collo Motor6D viene rimosso o disconnesso anche solo momentaneamente.Questa proprietà predefinisce vero.

RigType descrive se un Humanoid utilizza il vecchio Piattaforma di testdi caratteri R6, o il più recente Piattaforma di testdi caratteri R15.

Il rig R6 utilizza 6 visibili Parts mentre il rig R15 utilizza 15 visibili Parts .Le piattaforme R15 hanno più articolazioni delle piattaforme R6, rendendole molto più versatili quando vengono animati.

Nota che se questa proprietà è impostata in modo errato, il Humanoid non funzionerà correttamente.Ad esempio, se il RigType di un umanoide R15 è impostato su R6, il Humanoid morirà poiché non c'è BasePart chiamato Torso connesso a un BasePart chiamato Testa .

Un riferimento all'oggetto HumanoidRootPart dell'umanoide, la parte motrice della radice dell'Humanoid che controlla il movimento di un umanode nel Mondo3D.Questa parte è normalmente invisibile.

Per i personaggi R15, Model.PrimaryPart del modello Player.Character è impostato su HumanoidRootPart .

Per i personaggi R6, Model.PrimaryPart è impostato sulla parte Head .

SeatPart è un riferimento al sedile in cui un Humanoid è attualmente seduto, se presente.Il valore di questa proprietà può essere un Seat , o un VehicleSeat .Sarà nil se l'Humanoid non è attualmente seduto in un sedile.

Nota:

• Per un bool che descrive se il Humanoid è attualmente seduto o meno, vedi Humanoid.Sit

La proprietà Sit è un booleano che indica se il Humanoid è attualmente seduto.Humanoids può essere forzato in uno stato seduto impostando il valore di questa Proprietàa vero.Se il Humanoid non è allegato a un sedile mentre è in stato seduto, si imporrà con nessuna collisione nelle sue gambe.Un Humanoid può fuggire dallo stato seduto saltando.

Nota:

• Il Seat o VehicleSeat il Humanoid è seduto su può essere ottenuto utilizzando la ProprietàHumanoid.SeatPart
• È possibile rilevare quando un Umanoide si siede connesso all'evento Humanoid.Seated .

Non utilizzare Questa proprietà funziona solo con Modalità sperimentale abilitata, che è stata completamente interrotta.

Questa proprietà descrive una posizione 3D nello spazio in cui il Player controlla questa Humanoid ultima cliccata con un Tool equipaggiato.

Questa proprietà è principalmente utilizzata da strumenti classici per determinare ciò che un umanoide sta mirando quando attiva uno strumento.Se dai a un NPC un lanciatore di razzi classico, imposta il loro Punto di destinazione e poi chiama la funzione Tool:Activate() del tool, puoi far esplodere il NPC un razzo al punto di destinazione.

Quando un personaggio viene generato, questa proprietà viene impostata secondo il valore di StarterPlayer.CharacterUseJumpPower che predefinisce vero.

Durante il salto, con questo impostato su vero, il valore Humanoid.JumpHeight viene utilizzato per garantire i salt umanoidi a quell'altezza.Con questo impostato su false, il valore Humanoid.JumpPower viene utilizzato per applicare una forza ascendente.

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

Notizie

• Quando viene controllato su un dispositivo mobile o su un gamepad, un umanoide può camminare più lentamente del suo WalkSpeed.
• Puoi congelare un umanoide in loco impostando WalkSpeed a 0; ciò impedisce al giocatore di controllo di spostarlo attraverso i meccanismi di movimento predefiniti.
• Lo script di animazione predefinito scala le animazioni di movimento di un umanoide in base alla velocità con cui si muove rispetto alla velocità predefinita di 16 studs/secondo.
• La velocità a cui l'Humanoid è attualmente in camminata può essere ottenuta utilizzando l'evento Running.

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

Quando WalkToPart è impostato e un umanoide sta attivamente cercando di raggiungere la parte, manterrà l'aggiornamento del suo obiettivo Vector3 per essere la posizione della parte, più il Humanoid.WalkToPoint tradotto nello spazio oggetto rispetto alla rotazione della parte.

Questo può essere descritto in Luau come:

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

Avvertenze

• Impostare il valore di WalkToPart non è abbastanza sufficiente per fare un avvio umanoide dopo una parte.
• L'Humanoid viene invitato a iniziare a tentare di raggiungere un obiettivo quando il valore di WalkToPoint viene cambiato.
• Questo può essere cambiato in futuro.
• Lo stato di raggiungimento dell'obiettivo di un umanoide scadrà dopo 8 secondi se non raggiunge il suo obiettivo.
• Questo viene fatto in modo che i NPC non si blocchino in attesa di Humanoid.MoveToFinished per essere Lanciare.
• Se non vuoi che ciò accada, dovresti chiamare ripetutamente MoveTo in modo che il timeout continui a essere ripristinato.

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'umanode.

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

Avvertenze

• Il valore di WalkToPoint deve essere cambiato in un valore diverso per far in modo che l'umanoide inizi a camminare verso di esso.
• Se vuoi fare una passeggiata umanoide a 0,0,0 , dovresti usare la funzione MoveTo dell'umanoid.
• Questo può essere cambiato in futuro.
• Lo stato di raggiungimento dell'obiettivo di un umanoide scadrà dopo 8 secondi se non raggiunge il suo obiettivo.
• Questo viene fatto in modo che i NPC non si blocchino in attesa di Humanoid.MoveToFinished per essere Lanciare.
• Se non vuoi che ciò accada, dovresti chiamare ripetutamente MoveTo in modo che il timeout continui a essere ripristinato.

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 al parentdell'umanoide.

Quando questo metodo viene chiamato, un viene attaccato al personaggio cercando un in il genitore dell'umanoide che condivide lo stesso nome di un nell'impugnatura dell'Accessorio.Se uno viene trovato, la parte Maniglia sarà connessa al padre del Attachment utilizzando un Weld , e il saldaggio sarà configurato in modo che l'Attachments occupi lo stesso Spazio.

Se il richiesto Attachment non può essere trovato, allora il Accessory rimarrà genitoriale al genitore dell'umanoide ma sarà disconnesso.

Tipicamente, i saldi accessori vengono creati sul Server, ma possono essere creati sul client sotto determinate condizioni.In queste situazioni, le chiamate lato client a AddAccessory() potrebbero non sempre produrre il comportamento desiderato e puoi usare BuildRigFromAttachments() per forzare la Creazionidel saldamento prevista.

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 connessioni per il Humanoid . Motor6D connessioni sono richieste per il riproduzione di Animations .

A partire dall'humanoide di RootPart , questo metodo raccoglie tutti i Attachments genitori nella parte attuale il cui nome termina con RigAttachment .Quindi cerca un allegato corrispondente nel personaggio che condivide lo stesso nome dell'allegato.Usando quei due allegati, viene generato un allegato congiunto Motor6D in base alle parti associate ai due allegati e al CFrame degli allegati.

Humanoid:BuildRigFromAttachments() anche scala 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

Questo metodo fa in modo che il Humanoid entri nel dato Enum.HumanoidStateType, descrivendo l'attività che il Humanoid sta attualmente svolgendo.

Si prega di rivedere la pagina Enum.HumanoidStateType per ulteriori informazioni sui singoli stati, poiché alcuni hanno nomi poco intuitivi.Ad esempio, Enum.HumanoidStateType.Running descrive uno stato in cui le gambe dell'umanoide sono a terra, incluso quando sono ferme.

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

• Impostare lo stato a Enum.HumanoidStateType.Swimming quando l'umanoide non è in acqua causerà il suo essere automaticamente impostato a Enum.HumanoidStateType.GettingUp .
• Poiché non viene utilizzato, impostare lo stato a Enum.HumanoidStateType.PlatformStanding causerà lo stato umanoide di essere automaticamente impostato a Enum.HumanoidStateType.Running .

Nota che per impostare lo stato Humanoid usando questo metodo, devi farlo da un LocalScript e il client deve avere proprietà di rete del Player.Character.In alternativa, puoi chiamare questo metodo da un lato server Script , ma il server deve avere la proprietà di rete del personaggio del giocatore.

Vedi anche Humanoid:SetStateEnabled() per abilitare o disabilitare uno stato particolare, e Humanoid:GetState() per ottenere lo stato umanoide attuale.

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)

Questo metodo fa in modo che il Humanoid equipaggi il dato Tool .

L'esempio seguente causerebbe un Player per equipaggiare uno strumento in Workspace chiamato 'Strumento' .

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 questo metodo viene chiamato, il Humanoid prima equipaggerà automaticamente tutto Tools che attualmente ha equipaggiato.

Anche se saranno equipaggiati, Tools per cui Tool.RequiresHandle è vero non funzionerà se non hanno una gestire, indipendentemente dal fatto che questo metodo venga utilizzato per equipaggiarli o meno.

Vedi anche:

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

Parametri

Restituzioni

Questo metodo restituisce un array di Accessory oggetti che l'humanoide del padre sta attualmente indossando.Tutti questi oggetti Accessory saranno inclusi, indipendentemente dal fatto che siano allegati o meno.

Se il Humanoid non ha oggetti Accessory, verrà restituito un array vuoto.

Vedi anche Humanoid:AddAccessory() per attaccare un Accessory a un 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)

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

Vedi anche

• Players:GetHumanoidDescriptionFromUserId() che restituisce un HumanoidDescription che descrive l'avatar per l'utente passato.
• Players:GetHumanoidDescriptionFromOutfitId() che restituisce un HumanoidDescription i cui parametri vengono inizializzati per corrispondere a quelli dell'risorsadell'outfit lato server passato.
• Player:LoadCharacterWithHumanoidDescription() che genera un giocatore con lo sguardo da quello passato in HumanoidDescription .

Restituzioni

Questo metodo restituisce ciò che Enum.BodyPartR15 un Part è, o Enum.BodyPartR15.Unknown se la parte non è una parte del corpo R15.Questo metodo consente agli sviluppatori di recuperare parti del corpo del giocatore indipendenti da ciò che sono i nomi effettivi delle parti del corpo, restituendo invece un'Enum.

Può essere utilizzato in combinazione con Humanoid:ReplaceBodyPartR15() .Ad esempio, se una parte del corpo di un Giocatoretocca qualcosa, questa funzione restituirà un'istanza di parte.Gli sviluppatori possono quindi cercare quale parte del corpo era, come testa o braccio.Quindi a seconda di quale parte era, gli sviluppatori possono eseguire un'azione di gioco o sostituire quella parte con un'altra parte - forse mostrando danni.

Questo metodo può essere utile per giochi in cui la posizione del colpo è importante.Ad esempio, può essere utilizzato per determinare se un giocatore viene colpito alla gamba e quindi rallentarlo in base all'infortunio.

Parametri

Restituzioni

Questo metodo restituisce l'enumerazione Enum.Limb che è associata al dato Part. 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 genitore della parte non è impostato sul parentdell'umanoide.

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

Questo metodo restituisce l'attuale Enum.HumanoidStateType dell'umanide, che descrive l'attività che l'Humanoid sta attualmente svolgendo, come il salto o la nuotata.

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

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)

Il metodo GetStateEnabled restituisce se un Enum.HumanoidStateType è abilitato per il Humanoid .

Lo stato umanoide descrive l'attività che l'umanode sta attualmente svolgendo.

Quando un particolare Enum.HumanoidStateType è disabilitato, l'umanoide non può mai entrare in quello stato.Questo è vero indipendentemente se l'attempt to change state viene eseguito utilizzando Humanoid:ChangeState() o codice umanoide interno di Roblox.

Vedi anche:

• Per un evento che si attiva quando uno stato umanoide è abilitato o disabilitato vedi Humanoid.StateEnabledChanged
• Per abilitare o disabilitare uno stato Humanoid di uso 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

Questo metodo fa in modo che il Humanoid cammini nella direzione Vector3 data.

Per impostazione predefinita, la direzione è in Condizionidi mondo, ma se il parametro relativeToCamera è true, la direzione è relativa al CFrame del CurrentCamera .Poiché la direzione negativa Z viene considerata "in avanti" in Roblox, il seguente codice farà camminare l'umanoide nella direzione di CurrentCamera.

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

Quando questo metodo viene chiamato, il Humanoid si muoverà fino a quando il metodo verrà nuovamente chiamato.Tuttavia, questo metodo verrà sovrascritto nel prossimo frame dallo script di controllo del personaggio predefinito di Roblox.Questo può essere evitato chiamando questa funzione ogni frame utilizzando RunService:BindToRenderStep() (vedi esempio), o sovrascrivendo gli script di controllo in StarterPlayerScripts .

Questo metodo può essere chiamato sul Server, ma ciò dovrebbe essere fatto solo quando il server ha proprietà di rete dell'assemblaggio umanoide.

Vedi anche Humanoid:MoveTo() che fa un Humanoid camminata a 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)

Questo metodo fa in modo che il Humanoid tenti di camminare verso la posizione data impostando le proprietà Humanoid.WalkToPoint e Humanoid.WalkToPart.

I parametri luogo e parte corrispondono a quelli che verranno impostati su Humanoid.WalkToPoint e Humanoid.WalkToPart.

Se il parametro parte è specificato, il Humanoid ancora tenterà di camminare al punto.Tuttavia, se la parte si muove allora il punto il Humanoid è in cammino per essere alla stessa posizione rispetto alla parte .Se il parametro parte non è specificato, la posizione a cui la Humanoid non cambierà.

Lo stato di raggiungimento dell'obiettivo di un umanoide scadrà dopo 8 secondi se non raggiunge il suo obiettivo.Questo viene fatto in modo che i NPC non si blocchino in attesa di Humanoid.MoveToFinished per essere Lanciare.Se non vuoi che ciò accada, dovresti chiamare ripetutamente MoveTo in modo che il timeout continui a essere ripristinato.

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

• Il personaggio arriva alla sua destinazione. C'è una soglia ~1 di stud per tenere conto di varie velocità e frequenze di fotogrammi umanoidi.

• Il personaggio si blocca e il timer di otto secondi scade.

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

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

• Un script cambia la proprietà CFrame del 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)

Questo metodo rimuove tutti gli oggetti Accessory indossati dal parentdell'umanoide. Per il giocatore Characters, questo rimuoverà tutti i cappelli e altri accessori.

Questo metodo rimuove l'oggetto Accessory chiamando Instance:Destroy() su di esso, il che significa che il Parent degli accessori è impostato su nil e bloccato.

Vedi anche Humanoid:AddAccessory() per aggiungere un Accessory , e Humanoid:GetAccessories() per ottenere tutti gli oggetti Accessory appartenenti a un Humanoid .

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)

Sostituisce dinamicamente una parte del braccio R15/Rthro in un Umanoide con una parte diversa. La parte viene automaticamente ridimensionata come al solito.

Questo metodo è utile per modificare i personaggi durante il gioco o costruire personaggi da una base Piattaforma di test.Il metodo correlato GetBodyPartR15 può essere utile quando si usa questo metodo.

Il nome della parte passata deve corrispondere al nome della BodyPartR15 Enum passata in.

Parametri

Restituzioni

Questo metodo imposta se un dato Enum.HumanoidStateType è abilitato per il Humanoid .Quando un particolare Enum.HumanoidStateType è disabilitato, il Humanoid non può mai entrare in quello stato.Questo è vero indipendentemente se l'attempt to change state viene eseguito utilizzando Humanoid:ChangeState() o codice interno Roblox Humanoid.

Nota che l'utilizzo 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)

Questo metodo riduce il Humanoid.Health del Humanoid con l'importo fornito ** se non è protetto da un ForceField

Questo metodo accetta valori negativi per il parametro quantità.Ciò aumenterà l'umanoide di Humanoid.Health .Tuttavia questo avrà effetto solo se non è presente ForceField .

Come proteggono i ForceField contro il TakeDamage

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

• Il ForceField condivide lo stesso Instance.Parent come il Humanoid
• Il ForceField è parented to the Humanoid.RootPart del Humanoid
• Il ForceField è parented to un antenato del Humanoid diverso dal Workspace

Per infliggere danni a un Humanoid indipendentemente da qualsiasi ForceFields presente, imposta Humanoid.Health direttamente.

Per ulteriori informazioni su come ForceFields proteggere Humanoids vedi la pagina ForceField.

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)