Humanoid
*Questo contenuto è tradotto usando AI (Beta) e potrebbe contenere errori. Per visualizzare questa pagina in inglese, clicca qui.
L'Humanoid è un oggetto speciale che dà ai modelli la funzionalità di un personaggio.Garanzia al modello la possibilità di camminare fisicamente e interagire con diverse componenti di un'esperienza Roblox.Gli umanoidi sono sempre genitori all'interno di un Model , e il modello è previsto di essere un'assemblaggio di BasePart e Motor6D ; la parte radice dell'assemblaggio è prevista di essere nominata HumanoidRootPart .Si aspetta inoltre che una parte chiamata Head venga collegata alla parte del torso del personaggio, direttamente o indirettamente.Per impostazione predefinita, ci sono due tipi ufficiali di righe di personaggio fornite da Roblox, ognuna con il proprio set di regole:
R6
- Un rig di base per personaggi che utilizza 6 parti per le membra.
- La parte Head deve essere allegata a una parte chiamata Torso , o l'Humanoid morirà immediatamente.
- Le apparenze delle parti del corpo sono applicate utilizzando CharacterMesh.
- Alcune proprietà, come Humanoid.LeftLeg e Humanoid.RightLeg, funzionano solo con R6.
R15
- Più complesso di R6, ma anche molto più flessibile e robusto.
- Utilizza 15 parti per le membra.
- La parte Head deve essere allegata a una parte chiamata UpperTorso o l'Humanoid morirà immediatamente.
- Le apparenze delle parti del corpo devono essere assemblate direttamente.
- Può essere ridimensionato dinamicamente utilizzando oggetti speciali NumberValue genitori all'interno dell'Humanoid.
- L'Umanoide creerà automaticamente oggetti Vector3Value chiamati OriginalSize all'interno di ogni arta.
- Se un NumberValue è genitoriale all'interno dell'Humanoid e ha il nome di uno dei Seguendo, verrà utilizzato per controllare la funzionalità di ridimensionamento:
- Scala di profondità del corpo
- Scala dell'altezza del corpo
- Scala della larghezza del corpo
- Dimensione Testa
Campioni di codice
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
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)
Sommario
Proprietà
Imposta se il personaggio salterà automaticamente quando colpisce un ostacolo come giocatore su un Dispositivomobile.
AutoRotate imposta se l'Humanoid si girerà automaticamente verso la direzione in cui si muove o meno.
Quando è abilitato, AutomaticScalingEnabled causa la dimensione del personaggio a cambiare in risposta ai valori nei valori della scala del figlio dell'umanoide che cambiano.
Determina se le articolazioni dell'umanoide si rompono quando è nello stato Enum.HumanoidStateType.Dead .
Un offset applicato alla posizione soggetto della fotocamera quando il suo CameraSubject è impostato su questo Umanoide.
Controlla il comportamento della distanza del nome e della salute dell'oidoide umano.
Imposta il testo di un Umanoide, visualizzato sopra la loro testa.
Descrive il Enum.Material che l'Humanoid è attualmente in piedi.Se il Humanoid non sta su nulla, il valore di questa proprietà sarà Aria .
Descrive la salute attuale dell'Humanoid sul raggio [0, Humanoid.MaxHealth].
Utilizzato in combinazione con la proprietà DisplayDistanceType per controllare la distanza da cui la barra della salute di un umanoide può essere vista.
Controlla quando la barra della salute dell'umanoide è consentita di essere visualizzata.
Determina la distanza dal suolo che il Humanoid.RootPart dovrebbe essere.
Se true , il Humanoid salta con una forza verso l'alto.
Fornisce il controllo sull'altezza a cui il Humanoid salta.
Determina quanta forza verso l'alto viene applicata al Humanoid quando si salta.
Il valore massimo di un umanoide di Health .
L'angolo di pendenza massimo su cui un umanoide può camminare senza scivolare.
Descrive la direzione in cui il Humanoid cammina.
Utilizzato in combinazione con la proprietà Humanoid.DisplayDistanceType per controllare la distanza da cui il nome di un umanoide può essere visto.
Controlla se il nome e la barra della salute di un umanoide possano essere visti dietro le pareti o altri oggetti.
Determina se il Humanoid è attualmente nello stato Enum.HumanoidStateType.PlatformStanding.
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.
Descrive se questo Humanoid utilizza il vecchio Piattaforma di testpersonaggio R6, o il nuovo Piattaforma di testpersonaggio R15.
Un riferimento all'oggetto HumanoidRootPart dell'umanoide.
Un riferimento al sedile in cui un Humanoid è attualmente seduto, se presente.
Descrive se il Humanoid è attualmente seduto.
Descrive la posizione 3D in cui il Player controlla l'ultimo Humanoid cliccato nel mondo utilizzando un Tool .
Determina se la proprietà JumpHeight (false) o Humanoid.JumpPower (true) viene utilizzata.
Descrive la velocità di movimento massima dell'umanoide in studs al secondo.
Un riferimento a una parte la cui posizione viene cercata di raggiungere da un umanoide
La posizione che un umanoide sta cercando di raggiungere, dopo una chiamata a Humanoid:MoveTo() è stata fatta.
Metodi
Aggiunge il specificato Accessory al parentdell'umanoide.
Assembla un albero di Motor6D connessioni con l'aggancio di oggetti Attachment insieme nel personaggio di un umanoide.
Imposta il Humanoid per entrare nel dato Enum.HumanoidStateType.
Restituisce un array di Accessory oggetti che l'humanoide del suo genitore sta indossando attualmente.
Restituisce una copia del cache dell'umanoide HumanoidDescription che descrive il suo aspetto attuale.
Passa una parte del corpo a questo metodo (la parte del corpo dovrebbe essere un fratello di Humanoid, e un figlio di un Modello) per ottenere il Enum.BodyPartR15 della Part.
Restituisce l'enumerazione Enum.Limb che è associata al dato Part.
Restituisce l'attuale Enum.HumanoidStateType dell'umanoide.
Restituisce se un Enum.HumanoidStateType è abilitato per il Humanoid .
Causa il Humanoid a camminare nella direzione data.
Causa il Humanoid a tentare di camminare verso la posizione data impostando le proprietà Humanoid.WalkToPoint e Humanoid.WalkToPart.
Rimuove tutti gli oggetti Accessory indossati dal parentdell'oido umanoide
Sostituisce dinamicamente una parte del corpo umanoide con una parte diversa.
Imposta se un dato Enum.HumanoidStateType è abilitato per il Humanoid .
Abbassa il del per l'importo dato se non è protetto da un .
Disequipaggia qualsiasi Tool attualmente equipaggiato dal Humanoid .
- ApplyDescription(humanoidDescription : HumanoidDescription,assetTypeVerification : Enum.AssetTypeVerification):()
Fa corrispondere l'aspetto del personaggio a quello passato in HumanoidDescription .
- ApplyDescriptionReset(humanoidDescription : HumanoidDescription,assetTypeVerification : Enum.AssetTypeVerification):()
Fa corrispondere l'aspetto del personaggio a quello del passato in HumanoidDescription , anche dopo modifiche esterne.
Riproduce le emote e restituisce se è stato eseguito con successo.
Eventi
Si accende quando la velocità a cui un Humanoid sta salendo cambia.
Si accende quando il Humanoid muore.
Si accende quando il Humanoid entra o esce dal FallingDown``Enum.HumanoidStateType .
Si accende quando il Humanoid entra o esce dal Freefall``Enum.HumanoidStateType .
Si accende quando il Humanoid entra o esce dal GettingUp``Enum.HumanoidStateType .
Si accende quando i Humanoid.Health cambia (o quando il Humanoid.MaxHealth è Impostare).
Si accende quando il Humanoid entra e lascia il Jumping``Enum.HumanoidStateType .
Si accende quando il Humanoid finisce di camminare verso un obiettivo dichiarato da Humanoid:MoveTo() .
Si accende quando il Humanoid entra o esce dal PlatformStanding``Enum.HumanoidStateType .
Si accende quando il Humanoid entra o esce dal Ragdoll``Enum.HumanoidStateType .
Si accende quando la velocità a cui è in esecuzione un Humanoid cambia.
Spedito quando un Humanoid è seduto in un Seat o VehicleSeat si alza.
Si accende quando lo stato del Humanoid viene cambiato.
Si accende quando Humanoid:SetStateEnabled() viene chiamato sul Humanoid .
Si accende quando il Humanoid entra o esce dal StrafingNoPhysics``Enum.HumanoidStateType .
Si accende quando la velocità a cui un Humanoid nuota in acqua cambia in Terrain .
Si accende quando uno dei membri dell'umanoide viene a contatto con un altro BasePart .
Proprietà
AutoJumpEnabled
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.
Campioni di codice
This code sample is meant for a TextButton. It allows the player to toggle the auto-jumping behavior while on a mobile device.
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()
AutoRotate
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>
Tipo di rotazione |
---|
Campioni di codice
This script adds the functionality of a button to a part, which switches the AutoRotate property of whoever touches it.
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
AutomaticScalingEnabled
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.
BreakJointsOnDeath
Determina se le articolazioni dell'umanoide si rompono quando è nello stato Enum.HumanoidStateType.Dead . Predefinito vero.
CameraOffset
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.
Campioni di codice
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
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)
DisplayDistanceType
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.
Campioni di codice
This example demonstrates how to set a Humanoid's Humanoid.DisplayerDistanceType, Humanoid.HealthDisplayDistance, and Humanoid.NameDisplayDistance properties. These properties determine how a humanoid's healthbar and name are rendered for a player.
First, we change the DisplayDistanceType to Viewer using Enum.HumanoidDisplayDistanceType. When set to viewer, the humanoid's Name and healthbar will be displayed based on the distance settings of the humanoid viewing them.
Then, the humanoid's HealthDisplayDistance is set to 0. Setting the property to 0 hides the healthbar completely. It is not displayed at any distance.
Finally, the humanoid's NameDisplayDistance is set to 100. This means that the humanoid's name will be visible to other humanoid's within 100 studs.
This example should work as expected when placed inside a Script that is a child of the humanoid.
local humanoid = script.Parent
humanoid.DisplayDistanceType = Enum.HumanoidDisplayDistanceType.Viewer
humanoid.HealthDisplayDistance = 0
humanoid.NameDisplayDistance = 100
DisplayName
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.
EvaluateStateMachine
FloorMaterial
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().
Health
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.
HealthDisplayDistance
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.
HealthDisplayType
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.
HipHeight
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
Jump
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.
JumpHeight
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).
JumpPower
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).
MaxHealth
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.
MaxSlopeAngle
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.
Campioni di codice
The example below demonstrates the effect of the MaxSlopAngle property by limiting the maximum slope the Players.LocalPlayer can walk up to 30°. The local player will slide down any slope greater than 30°.
This code below works as expected when placed in a LocalScript.
local player = game.Players.LocalPlayer
local char = player.CharacterAdded:wait()
local h = char:FindFirstChild("Humanoid")
h.MaxSlopeAngle = 30
MoveDirection
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.
Campioni di codice
This LocalScript makes the camera bobble as the player's character walks around, utilizing both the Humanoid's CameraOffset and MoveDirection. It should be parented inside of the StarterCharacterScripts so that it is distributed into a player's character as expected.
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)
NameDisplayDistance
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.
NameOcclusion
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.
Campioni di codice
In the below example, Player|Players will not be able to see each other's Player.Character names when they are obscured behind BasePart|BaseParts.
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)
PlatformStand
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.
RequiresNeck
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
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 .
RootPart
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
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
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 .
TargetPoint
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.
UseJumpPower
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.
WalkSpeed
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.
WalkToPart
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
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.
Campioni di codice
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
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)
Metodi
AddAccessory
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
Campioni di codice
This script generates the "Clockwork's Shades" Accessory from scratch, and then attaches it to the player's character using Humanoid.AddAccessory You should paste this code into a regular script, and then parent it inside of the StarterPlayer's StarterCharacterScripts folder.
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)
BuildRigFromAttachments
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
Campioni di codice
A Lua port of the Humanoid's BuildRigFromAttachments function, so that the recursive behavior of the function can be seen.
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)
A script that generates an R15 character from scratch using a package's assetId.
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
ChangeState
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
Il Enum.HumanoidStateType che il Humanoid deve eseguire.
Restituzioni
Campioni di codice
This code, when placed inside a LocalScript in StarterPlayer.StarterCharacterScripts, will allow the player's character to perform a double jump.
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)
EquipTool
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 thenlocal humanoid = player.Character:FindFirstChildWhichIsA("Humanoid")if humanoid thenlocal tool = Workspace:FindFirstChild("Tool")if tool thenhumanoid:EquipTool(tool)endendend
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
GetAccessories
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
Campioni di codice
This code sample will wait for accessories to fully load, print out how many there are, and then destroy them all.
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)
GetAppliedDescription
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
GetBodyPartR15
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
La parte specificata viene controllata per vedere se è una parte del corpo R15.
Restituzioni
Il tipo di corpo R15 della parte specificata o sconosciuto se la parte non è una parte del corpo.
GetLimb
Questo metodo restituisce l'enumerazione Enum.Limb che è associata al dato Part. Funziona per entrambi i rig R15 e R6, ad esempio:
-- Per R15print(humanoid:GetLimb(character.LeftUpperLeg)) -- Enum.Limb.LeftLegprint(humanoid:GetLimb(character.LeftLowerLeg)) -- Enum.Limb.LeftLegprint(humanoid:GetLimb(character.LeftFoot)) -- Enum.Limb.LeftLeg-- Per R6print(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
Campioni di codice
Put this in a LocalScript. The output will vary based on if the humanoid is R6 or R15.
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
GetState
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
L'attuale Enum.HumanoidStateType dell'Humanoid.
Campioni di codice
This code, when placed inside a LocalScript in StarterPlayer.StarterCharacterScripts, will allow the player's character to perform a double jump.
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)
GetStateEnabled
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
Il dato Enum.HumanoidStateType .
Restituzioni
Se il dato Enum.HumanoidStateType è abilitato.
Campioni di codice
The code below sets the value of the humanoid jumping state to false using Humanoid:SetStateEnabled() and then retrieves and prints the value of this state (false) using Humanoid:GetStateEnabled().
local humanoid = script.Parent:WaitForChild("Humanoid")
-- Set state
humanoid:SetStateEnabled(Enum.HumanoidStateType.Jumping, false)
-- Get state
print(humanoid:GetStateEnabled(Enum.HumanoidStateType.Jumping)) -- false
Move
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
La direzione in cui camminare.
Imposta su true se il parametro moveDirection deve essere preso come relativo al CurrentCamera.
Restituzioni
Campioni di codice
This code sample uses the Humanoid:Move() function to make the player's Character walk in the direction of the Camera. RunService:BindToRenderStep() is required here as the default control scripts will overwrite the player's movement every frame.
To run this sample, place it inside a LocalScript parented to StarterCharacterScripts.
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)
MoveTo
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.
Parametri
La posizione per impostare Humanoid.WalkToPoint .
Il BasePart per impostare Humanoid.WalkToPart .
Restituzioni
Campioni di codice
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
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)
RemoveAccessories
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
Campioni di codice
This code sample will wait for accessories to fully load, print out how many there are, and then destroy them all.
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)
ReplaceBodyPartR15
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
La parte del corpo da sostituire. Enum.BodyPartR15.Unknown fallirà.
Il Class.Part``Class.Instance che sarà genitoriale al personaggio.
Restituzioni
SetStateEnabled
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
Il Enum.HumanoidStateType da abilitare o disabilitare.
true se state deve essere abilitato, false se state deve essere disabilitato.
Restituzioni
Campioni di codice
The following sample will require a one second cooldown after a Humanoid has landed before it is able to jump again.
To try this sample, place it inside a LocalScript in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
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)
TakeDamage
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:
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
Il danno, o l'importo da dedurre dal Humanoid.Health .
Restituzioni
Campioni di codice
This code, put in a LocalScript, would make the local player take 99 damage only if a ForceField wasn't present.
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)
UnequipTools
Questo metodo disequipaggia qualsiasi Tool attualmente equipaggiato da Humanoid
Il disequipaggiato Tool sarà genitoriale al Backpack del Player associato con il Humanoid .
Se non è equipaggiato alcun Tool, questo metodo non farà nulla.
Anche se Tools può essere equipaggiato da NPC (Non Player Characters), questo metodo funziona solo su Humanoids con un corrispondente Player.Questo perché è necessario un oggetto Backpack per genitoriare il disequipaggiato Tool .
Vedi anche:
- Per equipaggiare invece un Tool, usa Humanoid:EquipTool()
Restituzioni
Campioni di codice
The following sample will bind the U key to unequip any Tool|Tools the Player currently has equipped.
To use this sample, place it inside a LocalScript within StarterPlayerScripts|StarterPlayer.StarterPlayerScripts.
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)
ApplyDescription
Questo metodo di arrendimento rende l'aspetto del personaggio corrispondente a quello passato in HumanoidDescription .Una copia del passato HumanoidDescription viene memorizzata come il HumanoidDescription per il Humanoid.
Questo metodo viene ottimizzato facendo l'assunzione che solo questo metodo viene utilizzato per modificare l'aspetto del personaggio e non vengono apportati cambiamenti attraverso altri mezzi tra le chiamate.Se vengono apportate modifiche al personaggio tra le chiamate, questo metodo potrebbe non far riflettere il personaggio con precisione su ciò che è stato passato in HumanoidDescription.Se vuoi utilizzare questo metodo in combinazione con altri mezzi per aggiornare il personaggio, Humanoid:ApplyDescriptionReset() garantirà sempre che il personaggio rifletta quello passato in HumanoidDescription.
Vedi anche
- Humanoid:GetAppliedDescription() che restituisce il HumanoidDescription attualmente applicato all'humanoid.
- 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 .
Parametri
L'istanza HumanoidDescription che vuoi impostare per Corrispondeil personaggio.
Restituzioni
ApplyDescriptionReset
Questo metodo di arrendimento rende l'aspetto del personaggio corrispondente a quello del passato in HumanoidDescription , anche dopo modifiche esterne.Una copia del passato HumanoidDescription viene memorizzata come il HumanoidDescription per il Humanoid.
Questo metodo garantirà sempre che il personaggio rifletta quello passato in HumanoidDescription, anche se sono state apportate modifiche al personaggio non utilizzando il sistema HumanoidDescription (ad esempio non utilizzando ApplyDescriptionReset() o ApplyDescription() ).Questo è in contrasto con ApplyDescription() che è ottimizzato e può applicare erroneamente un HumanoidDescription se il personaggio è stato modificato attraverso mezzi diversi dal sistema HumanoidDescription.
Parametri
L'istanza HumanoidDescription che vuoi impostare per Corrispondeil personaggio.
Restituzioni
PlayEmote
Se l'emote non può essere riprodotta perché l'emoteName non è trovato nella HumanoidDescription, questo metodo darà un errore.Il metodo restituirà vero per indicare che l'emote è stata riprodotta con successo.
Parametri
nome dell'emote da giocare.
Restituzioni
riprodotto con successo.
Eventi
Climbing
Si accende quando la velocità a cui un Humanoid sta salendo cambia.
Humanoids può salire su scale fatte di Parts o TrussParts .
Humanoids salire al 70% del loro Humanoid.WalkSpeed .
Questo evento non si attiverà sempre con una velocità di 0 quando il Humanoid smetterà di salire.
Vedi anche:
- Per nuoto e corsa vedi gli eventi Humanoid.Swimming e Humanoid.Running
- Puoi anche rilevare quando un Humanoid è in salita utilizzando l'evento Humanoid.StateChanged
- Puoi disabilitare l'arrampicata utilizzando la funzione Humanoid:SetStateEnabled()
Parametri
Campioni di codice
local Players = game:GetService("Players")
local function onCharacterClimbing(character, speed)
print(character.Name, "is climbing at a speed of", speed, "studs / second.")
end
local function onCharacterAdded(character)
character.Humanoid.Climbing:Connect(function(speed)
onCharacterClimbing(character, speed)
end)
end
local function onPlayerAdded(player)
player.CharacterAdded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
Died
Questo evento si attiva quando il Humanoid muore, di solito quando Humanoid.Health raggiunge 0.Questo potrebbe essere causato sia dalla disconnessione della loro testa da loro Humanoid.Torso , o impostando direttamente la Proprietàdi salute.
Questo evento si attiva solo se il è un discendente del . Se il è disabilitato non verrà Lanciare.
Campioni di codice
The code below would print the player's name, followed by "has died!", whenever a player dies. For example, if the player was named "Shedletsky", "Shedletsky has died!" would be printed to the output when they died.
local Players = game:GetService("Players")
local function onPlayerAdded(player)
local function onCharacterAdded(character)
local humanoid = character:WaitForChild("Humanoid")
local function onDied()
print(player.Name, "has died!")
end
humanoid.Died:Connect(onDied)
end
player.CharacterAdded:Connect(onCharacterAdded)
end
Players.PlayerAdded:Connect(onPlayerAdded)
FallingDown
L'evento FallingDown si attiva quando il Humanoid entra e lascia il FallingDown``Enum.HumanoidStateType .
Il Humanoid entrerà nello stato GettingUp 3 secondi dopo che lo stato FallingDown è abilitato.Quando ciò accade, questo evento verrà attivato con un valore attivo di false e Humanoid.GettingUp verrà attivato con un valore attivo di vero .
Parametri
FreeFalling
Questo evento si attiva quando il Humanoid entra o esce dal Freefall``Enum.HumanoidStateType .
Il parametro attivo rappresenta se il > sta entrando o uscendo dallo stato >.
Anche se lo stato Freefall termina generalmente quando lo stato Humanoid raggiunge il suolo, questo evento può essere attivato con attivo uguale a falso se lo stato viene cambiato mentre lo stato Humanoid sta cadendo.Per questo motivo, dovresti usare Humanoid.StateChanged e ascoltare lo stato Landed quando un Humanoid è atterrato.
Parametri
GettingUp
Questo evento si attiva quando il Humanoid entra o esce dallo stato Enum.HumanoidStateType.GettingUp , uno stato di transizione che viene attivato poco dopo che il Humanoid entra negli stati FallingDown (3 secondi) o Ragdoll (1 secondo).
Quando un Humanoid tenta di rialzarsi, questo evento si attiverà prima con un active parametro di true prima di rialzarsi nuovamente con un active parametro di false .
Per forzare un Humanoid a cadere, usa la funzione Humanoid:ChangeState() con Enum.HumanoidStateType.FallingDown.
Parametri
HealthChanged
Questo evento si attiva quando i Humanoid.Health cambiano.Tuttavia, non spara se la salute aumenta da un valore uguale o superiore a Humanoid.MaxHealth .
Quando Humanoid.Health raggiunge zero, il Humanoid morirà e si Lanciarel'evento Humanoid.Died. Questo evento si attiverà con un valore di zero.
Parametri
Il nuovo valore di Humanoid.Health .
Campioni di codice
The following example determines the change in health, printing it to the output. It will only work in a LocalScript.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local function onCharacterAdded(character)
local humanoid = character:WaitForChild("Humanoid")
local currentHealth = humanoid.Health
local function onHealthChanged(health)
local change = math.abs(currentHealth - health)
print("The humanoid's health", (currentHealth > health and "decreased by" or "increased by"), change)
currentHealth = health
end
humanoid.HealthChanged:Connect(onHealthChanged)
end
player.CharacterAdded:Connect(onCharacterAdded)
This code sample allows you to create a simple color-changing health bar using two nested Frames. Paste this into a LocalScript on the inner frame.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
-- Paste script into a LocalScript that is
-- parented to a Frame within a Frame
local frame = script.Parent
local container = frame.Parent
container.BackgroundColor3 = Color3.new(0, 0, 0) -- black
-- This function is called when the humanoid's health changes
local function onHealthChanged()
local human = player.Character.Humanoid
local percent = human.Health / human.MaxHealth
-- Change the size of the inner bar
frame.Size = UDim2.new(percent, 0, 1, 0)
-- Change the color of the health bar
if percent < 0.1 then
frame.BackgroundColor3 = Color3.new(1, 0, 0) -- black
elseif percent < 0.4 then
frame.BackgroundColor3 = Color3.new(1, 1, 0) -- yellow
else
frame.BackgroundColor3 = Color3.new(0, 1, 0) -- green
end
end
-- This function runs is called the player spawns in
local function onCharacterAdded(character)
local human = character:WaitForChild("Humanoid")
-- Pattern: update once now, then any time the health changes
human.HealthChanged:Connect(onHealthChanged)
onHealthChanged()
end
-- Connect our spawn listener; call it if already spawned
player.CharacterAdded:Connect(onCharacterAdded)
if player.Character then
onCharacterAdded(player.Character)
end
Jumping
Questo evento si attiva quando il Humanoid entra e lascia il Jumping``Enum.HumanoidStateType .
Quando un Humanoid salta, questo evento si attiva con un active parametro di true prima di poco dopo sparare nuovamente con un active parametro di false .Questo secondo sparo non corrisponde ad un atterraggio Class.Humanoid``Landed usando Enum.HumanoidStateType``Class.Humanoid.StateChanged .
Puoi disabilitare il salto utilizzando la funzione Humanoid:SetStateEnabled().
Parametri
MoveToFinished
Questo evento si attiva quando il Humanoid finisce di camminare verso un obiettivo dichiarato dalle proprietà Humanoid.WalkToPoint e Humanoid.WalkToPart.
Le proprietà Humanoid.WalkToPoint e Humanoid.WalkToPart possono essere impostate singolarmente o utilizzando la funzione Humanoid:MoveTo().
Se il Humanoid raggiunge il suo obiettivo entro 8 secondi, questo evento tornerà con raggiunto come vero.Se l'obiettivo non viene raggiunto entro 8 secondi il Humanoid smetterà di camminare e il raggiunto sarà falso.Questo timeout può essere ripristinato chiamando nuovamente Humanoid:MoveTo() entro il periodo di tempo limite.
Parametri
Campioni di codice
This code sample includes a function that avoids the 8 second timeout on Humanoid:MoveTo() by calling Humanoid:MoveTo() again before the timeout elapses. It also includes an optional andThen parameter where developers can pass a function to be called when the humanoid reaches its destination.
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)
PlatformStanding
Questo evento si attiva quando il Humanoid entra o esce dal PlatformStanding``Enum.HumanoidStateType .
Mentre il Humanoid è nello stato PlatformStanding, la proprietà Humanoid.PlatformStand sarà vera .
Mentre Humanoid.PlatformStand è impostato su vero, il Humanoid non sarà in grado di Sposta. Per ulteriori informazioni, vedi la pagina per Humanoid.PlatformStand .
Il PlatformStand Enum.HumanoidStateType è stato associato alla parte ora disabilitata Platform. Nonostante ciò, può essere ancora utilizzato dai sviluppatori.
Parametri
Ragdoll
Questo evento si attiva quando il Humanoid entra o esce dal Ragdoll``Enum.HumanoidStateType .
Il parametro active avrà il valore true o false per indicare l'ingresso o l'uscita.
Usa Humanoid:SetStateEnabled() per disabilitare lo stato di GettingUp per rimanere nello stato Ragdoll.
Vedi anche:
- Humanoid.FallingDown per l'evento Humanoid connesso con lo stato FallingDown, che si comporta in modo simile a Ragdoll
Parametri
Running
Questo evento si attiva quando la velocità a cui è in esecuzione un Humanoid cambia.
Mentre esegue la copertura Humanoids , in media, il loro Humanoid.WalkSpeed in studs al secondo.
Quando il Humanoid smette di eseguire questo evento spara con una velocità di 0.
Vedi anche:
- Per nuoto e arrampicata vedi gli eventi Humanoid.Swimming e Humanoid.Climbing
- Puoi anche rilevare quando un Humanoid è in esecuzione utilizzando l'evento Humanoid.StateChanged
Parametri
Campioni di codice
Demonstrates connecting to the Humanoid.Running event. The event is connected to every player's humanoid that joins.
The function connected will print whether or not the humanoid is running based on the speed.
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
local character = localPlayer.Character or localPlayer.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local function onRunning(speed: number)
if speed > 0 then
print(`{localPlayer.Name} is running`)
else
print(`{localPlayer.Name} has stopped`)
end
end
humanoid.Running:Connect(function(speed: number)
onRunning(speed)
end)
Seated
Questo evento si attiva quando un Humanoid è seduto in o si alza da un Seat o VehicleSeat .
Quando un personaggio entra in contatto con un sedile, viene attaccato al sedile e viene riprodotta un'animazione di seduta.Per maggiori informazioni su questo, vedi la pagina Seat .
- Se il personaggio è seduto, il parametro active sarà vero e currentSeatPart sarà il sedile in cui si trova attualmente.
- Se il personaggio si alza da una sedia, il parametro active sarà falso e currentSeatPart sarà nil.
Vedi anche:
- Humanoid.Sit , che indica se un Umanoide è attualmente seduto
- Humanoid.SeatPart , che indica il sedile su cui un Umanoide è attualmente seduto, se presente.
Parametri
Campioni di codice
This code sample demonstrates when the local player's Character sits down or stands up. It should be placed inside a LocalScript within StarterCharacterScripts in order to run when the player's character spawns in.
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local function onSeated(isSeated, seat)
if isSeated then
print("I'm now sitting on: " .. seat.Name .. "!")
else
print("I'm not sitting on anything")
end
end
humanoid.Seated:Connect(onSeated)
StateChanged
Questo evento si attiva quando lo stato del Humanoid è cambiato.
Poiché non esiste uno stato umanoide "Inattivo, Inattiva, Inattivi", dovresti invece utilizzare l'evento Humanoid.Running o ascoltare la parte RootPart del Velocity per capire quando il Humanoid è fermo.
Vedi anche
- Humanoid:GetState() e Humanoid:ChangeState() per ottenere e impostare lo stato.
- Humanoid:SetStateEnabled() per abilitare e disabilitare stati specifici.
Parametri
Il inserisci / scrividi stato precedente dell'umanoide.
Il inserisci / scrividi stato attuale dell'umanoide.
Campioni di codice
Emits particles from the local player's Player.Character when they jump. To try this code sample, place it inside a LocalScript parented to StarterCharacterScripts.
local character = script.Parent
local primaryPart = character.PrimaryPart
-- create particles
local particles = Instance.new("ParticleEmitter")
particles.Size = NumberSequence.new(1)
particles.Transparency = NumberSequence.new(0, 1)
particles.Acceleration = Vector3.new(0, -10, 0)
particles.Lifetime = NumberRange.new(1)
particles.Rate = 20
particles.EmissionDirection = Enum.NormalId.Back
particles.Enabled = false
particles.Parent = primaryPart
local humanoid = character:WaitForChild("Humanoid")
local isJumping = false
-- listen to humanoid state
local function onStateChanged(_oldState, newState)
if newState == Enum.HumanoidStateType.Jumping then
if not isJumping then
isJumping = true
particles.Enabled = true
end
elseif newState == Enum.HumanoidStateType.Landed then
if isJumping then
isJumping = false
particles.Enabled = false
end
end
end
humanoid.StateChanged:Connect(onStateChanged)
The following sample will require a one second cooldown after a Humanoid has landed before it is able to jump again.
To try this sample, place it inside a LocalScript in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
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)
StateEnabledChanged
L'evento StateEnableChanged si attiva quando Humanoid:SetStateEnabled() viene chiamato sul Humanoid.
I parametri includono il Enum.HumanoidStateType in questione insieme a un bool che indica se questo stato è ora abilitato.
Vedi anche:
- Per trovare se uno stato è attualmente abilitato, usa Humanoid:GetStateEnabled()
- Per ascoltare le modifiche di stato Humanoid usa Humanoid.StateChanged
Parametri
Il Enum.HumanoidStateType per il quale è stato cambiato lo stato abilitato.
Vero se lo stato è ora abilitato.
Campioni di codice
When a humanoid state changes for the Players.LocalPlayer, the code below prints whether the state has been enabled or disabled.
This code should work as expected when placed in a LocalScript.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoid = character:WaitForChild("Humanoid")
local function onStateEnabledChanged(state, enabled)
if enabled then
print(state.Name .. " has been enabled")
else
print(state.Name .. " has been disabled")
end
end
humanoid.StateEnabledChanged:Connect(onStateEnabledChanged)
Strafing
Questo evento non si attiva quando il Humanoid sta bombardando e non dovrebbe essere utilizzato dai developer
Questo evento viene attivato quando il Humanoid entra o esce dal StrafingNoPhysics``Enum.HumanoidStateType .
Quando il Humanoid entra nello stato StrafingNoPhysics questo evento si attiverà con un parametro attivo di vero .L'evento si attiverà nuovamente con attivo uguale a falso quando il Humanoid lascia lo stato StrafingNoPhysics.
Questo evento è associato allo stato e non si attiva quando il si muove perpendicolarmente alla direzione a cui è rivolto.Questo stato è attualmente inutilizzato, se viene impostato utilizzando Humanoid:ChangeState() lo stato tornerà a RunningNoPhysics .
Parametri
Swimming
Questo evento si attiva quando la velocità a cui un Humanoid nuota in acqua Terrain cambia.
Humanoids nuota al 87.5% del loro Humanoid.WalkSpeed .
Questo evento non si attiverà sempre con una velocità di 0 quando il Humanoid smetterà di nuotare.
Vedi anche:
- Per esecuzione e arrampicata vedi gli eventi Humanoid.Running e Humanoid.Climbing
- Puoi anche rilevare quando un Humanoid nuota usando l'evento Humanoid.StateChanged
- Puoi disabilitare la nuotata utilizzando la funzione Humanoid:SetStateEnabled()
Parametri
Touched
Questo evento si attiva quando uno dei membri dell'umanoide viene a contatto con un altro BasePart .Il BasePart che il limbo sta toccando, insieme al limbo stesso, viene fornito.
Questo evento non si attiverà quando le membra appartenenti al Humanoid entreranno in contatto con se stesse.
Altre alternative
Anche se l'evento Humanoid.Touched è utile, dovresti considerare se ci sono alternative che meglio soddisfano le tue esigenze.
- Nella maggior parte dei casi, è consigliato connettere un evento di interesse invece, poiché l'evento sarà costantemente attivato quando l'umanoide si muove.Ad esempio, in un Giocodi dodgeball, sarebbe più pratico connettere un evento Touched per le palle piuttosto che usare Humanoid.Touched .
- Quando si cerca di capire quando il Humanoid è atterrato a terra, l'evento Humanoid.StateChanged è più adatto.In alternativa, puoi controllare Humanoid.FloorMaterial per vedere se l'umanoide sta su qualsiasi materiale non aereo.
Notizie
- La connessione a questo evento causerà la creazione di un TouchTransmitter in ogni artiglio.
- Al momento non esiste un equivalente di BasePart.TouchEnded per Humanoids .
Parametri
Campioni di codice
When placed inside a Player.Character model this code will give a player the 'Midas touch'. Everything their character touches will change to gold.
When the Humanoid dies, this change is undone and the golden BasePart|BaseParts are returned to their original state.
To test this out, place this code inside a Script and place it in StarterCharacterScripts|StarterPlayer.StarterCharacterScripts.
local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local partInfo = {}
local debounce = false
local function onHumanoidTouched(hit, _limb)
if debounce then
return
end
if not hit.CanCollide or hit.Transparency ~= 0 then
return
end
if not partInfo[hit] then
partInfo[hit] = {
BrickColor = hit.BrickColor,
Material = hit.Material,
}
hit.BrickColor = BrickColor.new("Gold")
hit.Material = Enum.Material.Ice
debounce = true
task.wait(0.2)
debounce = false
end
end
local touchedConnection = humanoid.Touched:Connect(onHumanoidTouched)
local function onHumanoidDied()
if touchedConnection then
touchedConnection:Disconnect()
end
-- undo all of the gold
for part, info in pairs(partInfo) do
if part and part.Parent then
part.BrickColor = info.BrickColor
part.Material = info.Material
end
end
end
humanoid.Died:Connect(onHumanoidDied)