Humanoid

AutoJumpEnabled legt fest, ob oder nicht der Humanoid versuchen wird, automatisch über ein Hindernis zu springen, auf das er zugeht.

Derzeit funktioniert diese Eigenschaft nur, wenn die folgenden Bedingungen zutreffen:

• Das Charaktermodell des Humanoids ist das Player.Character eines Player.
• Der Spieler in Frage verwendet Steuerung.

Wenn der Charakter eines Spieler:inerscheint, entspricht der Wert der Eigenschaftendem Wert des Spieler:inPlayer.AutoJumpEnabled Eigenschaft - was wiederum der EigenschaftenStarterPlayer.AutoJumpEnabled entspricht.

local Players = game:GetService("Players")

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

local function update()
	-- Aktualisierungstext des Buttons
	if player.AutoJumpEnabled then
		button.Text = "Auto-Jump is ON"
	else
		button.Text = "Auto-Jump is OFF"
	end
	-- Spiegel die Eigenschaft im Charakter des Spielers wider, wenn er eine hat
	if player.Character then
		local human = player.Character:FindFirstChild("Humanoid")
		if human then
			human.AutoJumpEnabled = player.AutoJumpEnabled
		end
	end
end

local function onActivated()
	-- Auto-Sprung umschalten
	player.AutoJumpEnabled = not player.AutoJumpEnabled
	-- Aktualisiere alles andere
	update()
end

button.Activated:Connect(onActivated)
update()

Die Eigenschaft AutoRotate beschreibt, ob der Humanoid automatisch in die Richtung gedreht wird, in die er sich bewegt.Wenn es auf wahr gesetzt wird, dreht sich das Charaktermodell schrittweise in Richtung ihrer Bewegungsrichtung, während der Humanoid herumläuft.Wenn auf false gesetzt, bleibt das Zeichenmodell in seiner aktuellen Rotation fixiert, es sei denn, eine drehende Kraft wird auf die HumanoidRootPart angewendet.

Wenn das Charaktermodell der Charakter eines Spieler:inist, dann wird das Verhalten der Rotation des Humanoids durch die EigenschaftenRotateType des Benuterspiel-Einstellungen beeinflusst.

Wenn die Eigenschaft AutoRotate auf wahr gesetzt ist, hat die Eigenschaft RotateType die folgenden Auswirkungen auf die Rotation des Humanoids:

<th>Verhalten</th>

    <th>Zusammenhang</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td>BewegungRelative</td>

    <td />

    <td />
  </tr>

  <tr>
    <td>Kamerarelativ</td>

    <td>Der Charakter wird sich drehen, um in Richtung Kamera zu drehen.</td>

    <td>Spieler hat seine Kamera in die erste Person vergrößert oder befindet sich im Shift-Sperrmodus.</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

Der Humanoid hat sechs Kinderskalenwerte, einschließlich BodyDepthScale, BodyHeightScale, BodyProportionScale, BodyTypeScale, BodyWidthScale, HeadScale.Das Ändern des Werts einer dieser Ursachen verändert die Körperteile und Zubehörteile des Charakters, aber nur, wenn AutomaticScalingEnabled wahr ist.

Bestimmt, ob die Gelenke des Humanoiden brechen, wenn er im Enum.HumanoidStateType.Dead Zustand ist. Standard ist auf wahr.

Die Eigenschaft CameraOffset gibt einen Versatz zur Kameraposition des Themas an, wenn seine Camera.CameraSubject auf diese Humanoid eingestellt ist.

Der Offset wird im Objekt-Raum angewendet, in Bezug auf die Ausrichtung des Humanoiden HumanoidRootPart.Zum Beispiel kompensiert ein Versatz Vector3 Wert von (0, 10, 0) den Kamerablick des Spieler:inum 10 Klötze über dem menschlichen Körper des Spieler:in.

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)

Die DisplayDistanceType Eigenschaft steuert das Distanzenverhalten des Namens- und Gesundheitsdisplays des Humanoiden.Diese Eigenschaft wird mit der Enum.HumanoidDisplayDistanceType Enum verwendet, die drei verfügbare Werte hat, jede mit ihren eigenen Regeln:

• Wenn auf Viewer gesetzt, sieht der Humanoid den Namen/die Gesundheit anderer Humanoiden innerhalb der Reichweite seines eigenen NameDisplayDistance und HealthDisplayDistance .
• Wenn es auf gesetzt wird, übernimmt der Humanoid die volle Kontrolle über seinen eigenen Namen und Gesundheitsanzeige durch seine und Werte.
• Wenn auf None gesetzt, erscheinen Name und Gesundheitsleiste des Humanoids in keinem Fall.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

local humanoid = script.Parent

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

DisplayName ist eine Eigenschaft, die die Namensanzeige des Humanoids bestimmt, wenn er sichtbar ist.Standardmäßig wird ein neuer Humanoid den Wert einer leeren Stringhaben.Wenn DisplayName leer ist, wird die Namensanzeige des Humanoiden standardmäßig auf das Eigenschaftendes übergeordnetes Teildes Humanoiden zurückgesetzt.

Spielercharakter-Laden

Wenn Spieler ihren Charakter laden, entweder automatisch oder durch die Verwendung von LoadCharacter(), wird der Humanoid, der durch die Engine erstellt wird, seine DisplayName Eigenschaft auf die Eigenschaftendes Spieler:inDisplayName setzen.

StarterCharacter und StarterHumanoid

Wenn ein Humanoid namens StarterHumanoid einem StarterPlayer übergeordnet wird oder ein Humanoid in einem Modell namens StarterCharacter vorhanden ist, wird die Eigenschaft DisplayName respektiert, wenn Charaktere von Spielern im Spiel geladen werden.Die Engine wird nur die DisplayName Eigenschaft des Humanoids mit der DisplayName Eigenschaft des Spielers überschreiben, wenn die Humanoid.DisplayName des StarterHumanoid eine leere Stringist.

Dies ist ein lesbare Eigenschaft, die beschreibt, auf welchem Enum.Material der Humanoid derzeit steht.Es funktioniert mit beiden regulären Parts- und Terrain-Voxelen.

Das Codebeispiel unten zeigt, wie man zuhört, wenn sich diese Eigenschaft mit Object:GetPropertyChangedSignal() ändert.Wenn sich das Material, auf dem sich der Humanoid befindet, ändert, druckt er eine Nachricht aus, die anzeigt, auf welchem neuen Material er steht.

local Humanoid = route.to.humanoid

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

Bedenken

• Wenn die Humanoid nicht auf einem Boden steht, wird der Wert dieser Eigenschaft auf Luft festgelegt.

  • Dies geschieht, weil Enum-Eigenschaften keinen leeren Wert haben können.
  • Dies kann zu Verwirrung führen, wenn ein Teil sein Material auf Luft eingestellt ist, obwohl Teile im Allgemeinen nicht mit diesem Material beginnen sollten.
• Das Charaktermodell des Humanoid muss mit dem Boden kollidieren können, sonst wird es nicht erkannt.

  • Du kannst nicht testen, ob das Humanoid mit dieser Eigenschaftenschwimmt. Du solltest stattdessen seine Humanoid:GetState() Funktion verwenden.

Diese Eigenschaft repräsentiert den aktuellen Zustand des Humanoid .Der Wert ist auf den Bereich zwischen 0 und MaxHealth begrenzt.Wenn der Humanoid tot ist, wird diese Eigenschaft ständig auf 0 gesetzt.

Beachten Sie, dass die TakeDamage()-Funktion verwendet werden kann, um von Health abzuziehen, anstatt die Eigenschaft direkt festzulegen.

Gesundheitsregeneration

Standardmäßig wird ein passives Gesundheitsregenerationsskript automatisch in Humanoiden eingefügt.Dies verursacht, dass nicht-tote Spielercharaktere 1% von MaxHealth jede Sekunde regenerieren.Um dieses Regenerationsverhalten zu deaktivieren, füge einen leeren Script namens Gesundheit zu StarterCharacterScripts hinzu.

Gesundheitsleiste-Anzeige

Wenn Health weniger als MaxHealth ist, wird eine Gesundheitsleiste in der Erfahrung angezeigt.Das Anzeigeverhalten der Gesundheitsleiste hängt von den HealthDisplayDistance und HealthDisplayType ab.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

Der Tod

Wenn der Wert der Gesundheit des Charakters auf 0 erreicht, wechselt der Humanoid automatisch in den Enum.HumanoidStateType.Dead Zustand.In diesem Zustand ist Health auf 0 gesperrt; jedoch gibt es keinen Fehler oder eine Warnung für die Einstellung des Health eines toten Humanoiden auf einen positiven nicht Null-Wert.

Diese Eigenschaft ist eine Zahl, die zusammen mit der Eigenschaft DisplayDistanceType verwendet wird, um die Entfernung zu kontrollieren, von der die Gesundheitsleiste eines Humanoiden gesehen werden kann.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

Diese Eigenschaft steuert, wann die Gesundheitsleiste eines Humanoiden angezeigt werden darf.Standardmäßig ist diese Eigenschaft auf DisplayWhenDamaged festgelegt, was die Gesundheitsleiste nur anzeigt, wenn die eines Humanoiden Health weniger als seine MaxHealth beträgt.Es kann auch auf AlwaysOn festgelegt werden, was die Gesundheitsleiste immer anzeigt, oder AlwaysOff , was verhindert, dass sie jemals angezeigt wird.

Beachten Sie, dass diese Eigenschaft unabhängig von der Eigenschaft des Humanoiden ist HealthDisplayDistance, die dafür verantwortlich ist, dass die Gesundheitsleiste bei bestimmten Entfernungen verschwindet.Wenn Humanoid.HealthDisplayType|HealthDisplayType auf AlwaysOn gesetzt ist, verschwindet es immer noch, abhängig davon, wie HealthDisplayDistance konfiguriert ist.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

Bestimmt die Entfernung (in Stollen) vom Boden aus, die der RootPart beim Stehen des Humanoiden sein sollte.Die RigType beeinflusst die Art, wie sich diese Eigenschaft verhält.

Für R15-Ringe ist eine geeignete Hüfthöhe voreingestellt, um sicherzustellen, dass die Höhe des RootPart korrekt ist.Die Höhe der Beine wird nicht verwendet.Die Gesamthöhe des Humanoiden kann in der folgenden Formel beschrieben werden:

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

Für R6-Ringe beschreibt HipHeight stattdessen einen relativen Versatz. Die Gesamthöhe des Humanoiden kann in der folgenden Formel beschrieben werden:

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

Wenn true , springt der Humanoid mit einer nach oben gerichteten Kraft gleich dem Wert von Humanoid.JumpPower oder der Höhe von Humanoid.JumpHeight , abhängig vom Wert von Humanoid.UseJumpPower .

Bietet Kontrolle über die Höhe eines Humanoid Sprungs, in Studs.Der Startwert dieser Eigenschaft wird durch den Wert von StarterPlayer.CharacterJumpHeight bestimmt, der auf 7.2 zurückfällt.

Obwohl das Festlegen dieser Eigenschaft auf 0 den Menschenoid effektiv davon abhalten wird zu springen, wird empfohlen, das Springen durch die Deaktivierung des Zustands Enum.HumanoidStateType.Jumping zu deaktivieren, durch Humanoid:SetStateEnabled().

Diese Eigenschaft ist nur im Eigenschaften-Fenster sichtbar, wenn Humanoid.UseJumpPower auf falsch eingestellt ist, da es sonst nicht relevant wäre (stattdessen wird Humanoid.JumpPower verwendet).

Bestimmt, wie viel seitliche Kraft auf die Humanoid angewendet wird, wenn gesprungen wird.Der Startwert dieser Eigenschaft wird durch den Wert von StarterPlayer.CharacterJumpPower bestimmt, der auf 50 festgelegt ist und zwischen 0 und 1000 eingeschränkt ist.Beachte, dass Sprünge auch durch die Eigenschaft Workspace.Gravity beeinflusst werden, die die Beschleunigung durch Gravitation bestimmt.

Obwohl das Festlegen dieser Eigenschaft auf 0 den Menschenoid effektiv davon abhalten wird zu springen, wird empfohlen, das Springen durch die Deaktivierung des Zustands Enum.HumanoidStateType.Jumping zu deaktivieren, durch Humanoid:SetStateEnabled().

Diese Eigenschaft ist nur im Eigenschaften-Fenster sichtbar, wenn Humanoid.UseJumpPower auf wahr eingestellt ist, da es sonst nicht relevant wäre (stattdessen wird Humanoid.JumpHeight verwendet).

Der maximale Wert eines Humanoiden Health .

Der Wert dieser Eigenschaft wird neben der Eigenschaft Health verwendet, um die Standard-Gesundheitsleisteanzeige zu skalieren.Wenn die Gesundheitsleiste eines Humanoiden erreicht, kann sie je nach seiner Eigenschaftennicht angezeigt werden.

Diese Eigenschaft legt den maximalen Neigungswinkel fest, den ein Humanoide erklettern kann.Wenn der Winkel eines Schräggrades größer als der MaxSlopeAngle eines Humanoiden ist, rutschen sie den Schräghang herunter.

Wenn ein Charakter erscheint, wird diese Eigenschaft entsprechend dem Wert von StarterPlayer.CharacterMaxSlopeAngle festgelegt.

Der Wert dieser Eigenschaft ist auf Werte zwischen 0° und 89° beschränkt.Es wird standardmäßig auf 89° eingestellt, so dass Humanoide im Grunde jede Steigung klettern können, die sie wollen.

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

h.MaxSlopeAngle = 30

Bewegungsrichtung ist eine lesbare Eigenschaft, die die Richtung beschreibt, in die ein Humanoid geht, als Einheitsvektor oder Vektorkraft.Die Richtung wird im Platzbeschrieben.

Da diese Eigenschaft nur lesbar ist, kann sie nicht von einem Script oder LocalScript festgelegt werden.

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)

Die Eigenschaft NameDisplayDistance ist eine Zahl, die in Kombination mit der Eigenschaft Humanoid.DisplayDistanceType verwendet wird, um die Entfernung zu kontrollieren, von der der Name eines Humanoiden gesehen werden kann.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

Steuert, ob der Name und die Gesundheitsleiste eines Humanoiden hinter Wänden oder anderen Objekten sichtbar sind.Diese Eigenschaft ist ein Enum.NameOcclusion und kann so konfiguriert werden, dass alle Namen, feindliche Namen oder die Verschleierung vollständig ausgeschlossen werden.

In Fällen, in denen das LocalPlayer keine Humanoid mit ihm verknüpft hat, gilt diese Eigenschaft stattdessen für das Thema Humanoid.

Siehe Charaktername/Gesundheitsanzeige für einen detaillierten Leitfaden zur Kontrolle des Aussehens von Charakternamen und Gesundheitsbalken.

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)

Bestimmt, ob das Humanoid derzeit im Enum.HumanoidStateType.PlatformStanding Zustand ist.Wenn wahr, befindet sich der Humanoid in einem Zustand, in dem er freifällt und sich nicht Verschiebungswerkzeugkann.Dieser Zustand verhält sich ähnlich wie Sitzen, mit Ausnahme, dass Springen den Humanoiden nicht vom Zustand befreit.

Ermöglicht es Entwicklern, das Verhalten zu deaktivieren, bei dem ein Spieler Character|character dies tut, wenn der Nacken Motor6D entfernt oder kurzzeitig getrennt wird.Diese Eigenschaft wird auf wahr zurückgesetzt.

RigType beschreibt, ob ein Humanoid den älteren R6-Zeichenrig verwendet oder den neueren R15-Zeichenrig.

Das R6-Gerät verwendet 6 sichtbare Parts, während das R15-Gerät 15 sichtbare Parts verwendet.R15-Rigs haben mehr Gelenke als R6-Rigs, was sie vielseitiger macht, wenn sie animiert werden.

Beachten Sie, dass, wenn diese Eigenschaft falsch festgelegt wird, die Humanoid nicht richtig funktioniert.Zum Beispiel, wenn der RigType eines R15-Humanoïdes auf R6 eingestellt ist, wird der sterben, da es keinen Torso gibt, der mit einem Kopf verbunden ist, der auf Head genannt wird.

Ein Verweis auf das Objekt des Humanoiden HumanoidRootPart , das die Wurzel steuert, die den Bewegungsablauf eines Humanoiden durch die 3D-Welt kontrolliert.Dieser Teil ist normalerweise unsichtbar.

Für R15-Zeichen wird Model.PrimaryPart des Player.Character-Modells auf HumanoidRootPart gesetzt.

Für R6-Zeichen wird Model.PrimaryPart auf den Teil Head festgelegt.

Sitzteil ist ein Verweis auf den Sitz, auf dem sich derzeit ein Humanoid befindet, falls vorhanden.Der Wert dieser Eigenschaft kann entweder ein Seat oder ein VehicleSeat sein.Es wird null sein, wenn der Humanoid sich derzeit nicht in einem Sitz befindet.

Hinweis:

• Für einen bool, der beschreibt, ob das Humanoid derzeit sitzt oder nicht, siehe Humanoid.Sit

Die Eigenschaft Sit ist ein Boolean, der anzeigt, ob das Humanoid derzeit sitzt.Humanoids kann durch Festlegen des Werts dieser Eigenschaftenauf wahr in einen Sitzzustand versetzt werden.Wenn das Humanoid nicht mit einem Sitz verbunden ist, während es in seinem Sitzzustand ist, wird es über einen Kollisionen stolpern, ohne dass es auf seinen Beinen landet.Ein Humanoid kann aus dem Sitzzustand entkommen, indem es springt.

Hinweis:

• Die Seat oder VehicleSeat die Humanoid sitzt auf kann mit der EigenschaftenHumanoid.SeatPart erhalten werden
• Es ist möglich zu erkennen, wenn ein Humanoid sitzt, indem er sich mit dem Humanoid.Seated-Ereignis verbindet.

Verwende nicht Diese Eigenschaft funktioniert nur mit aktiviertem Experimentiermodus, der vollständig eingestellt wurde.

Diese Eigenschaft beschreibt eine 3D-Position im Raum, in der die die letzte mit einem ausgerüstet wurde, mit der kontrolliert wird.

Diese Eigenschaft wird vor allem von klassischen Werkzeugen verwendet, um zu bestimmen, auf was sich ein Humanoid konzentriert, wenn es ein Toolaktiviert.Wenn du einem NPC einen klassischen Raketenwerfer gibst, setze seinen Zielpunkt und rufe dann die Funktion des Toolauf, kannst du den NPC eine Rakete am Zielpunkt abfeuern.

Wenn ein Charakter erscheint, wird diese Eigenschaft entsprechend dem Wert von StarterPlayer.CharacterUseJumpPower festgelegt, der standardmäßig auf true gesetzt ist.

Wenn Sie springen, mit diesem Wert auf wahr gesetzt, wird der Humanoid.JumpHeight Wert verwendet, um sicherzustellen, dass die menschlichen Sprünge auf diese Höhe springen.Mit diesem Wert auf false wird der Humanoid.JumpPower Wert verwendet, um eine aufwärts gerichtete Kraft anzuwenden.

Diese Eigenschaft beschreibt, wie schnell der Humanoid in Stollen pro Sekunde Gehenkann.Es wird der Wert von StarterPlayer.CharacterWalkSpeed (16) standardmäßig verwendet, was bedeutet, dass ein Spielercharakter jede Sekunde 16 Klötze in jede Richtung bewegen kann.

Anmerkungen

• Wenn er auf einem mobilen Gerät oder einem Gamepad gesteuert wird, kann ein Humanoid langsamer gehen als seine WalkSpeed, wenn der Steuerknopf nur einen graduellen Grad vom Zentrum entfernt bewegt wird.
• Du kannst einen Humanoiden an Ort und Stelle einfrieren, indem du WalkSpeed auf 0 festlegst; dies verhindert, dass der steuernde Spieler ihn durch die Standardbewegungsmechanismen bewegt.
• Das Standard-Animationsskript skaliert die Bewegungsanimationen eines Humanoiden basierend darauf, wie schnell er sich im Vergleich zur Standardgeschwindigkeit von 16 Stunden/Sekunde bewegt.
• Die Geschwindigkeit, mit der der Humanoid derzeit geht, kann mit dem Ereignis Running erhalten werden.

WalkToPart ist ein Verweis auf ein Teil, das der Humanoid erreichen versucht.Dieses Eigenschaft wird normalerweise festgelegt, wenn ein Teil als 2. Argument der Funktion des Humanoiden Humanoid:MoveTo() übergeben wird.

Wenn WalkToPart festgelegt ist und ein Humanoid versucht, das Teil zu erreichen, wird es seine Vector3-Zielstellung weiter aktualisieren, um die Position des Teils zu sein, plus die Humanoid.WalkToPoint übersetzt im Objektbereich im Verhältnis zur Rotation des Teils.

Dies kann in Luau wie folgt beschrieben werden:

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

Bedenken

• Die Festlegung des Werts von WalkToPart reicht nicht aus, um einen humanoiden Start nach einem Teil zu starten.
• Der Humanoid wird aufgefordert, zu versuchen, ein Ziel zu erreichen, wenn der Wert von WalkToPoint geändert wird.
• Dies kann in der Zukunft geändert werden.
• Der Erreiche-Ziel-Status eines Humanoiden läuft nach 8 Sekunden ab, wenn er sein Ziel nicht erreicht.
• Dies wird getan, damit NPCs nicht darauf feststecken, auf Humanoid.MoveToFinished zu warten, um zu initiieren.
• Wenn du nicht möchtest, dass dies passiert, solltest du MoveTo wiederholt aufrufen, damit der Timeout immer wieder zurückgesetzt wird.

WalkToPoint beschreibt die 3D-Position im Raum, die ein Humanoide erreichen möchte, nachdem er durch die Humanoid:MoveTo() -Funktion des Humanoiden dazu aufgefordert wurde.

Wenn der Humanoid.WalkToPart eines Humanoiden festlegenist, wird das Ziel durch die Transformation von WalkToPoint in Bezug auf die Position und Rotation der Teile festgelegt.Wenn WalkToPart nicht festlegenist, versucht der Humanoid, die angegebene 3D-Position direkt mit WalkToPoint zu erreichen.

Bedenken

• Der Wert von WalkToPoint muss auf einen anderen Wert geändert werden, damit der Humanoid beginnt, sich auf ihn zu bewegen.
• Wenn du einen humanoiden Spaziergang zu 0,0,0 machen möchtest, solltest du die MoveTo-Funktion des Humanoiden verwenden.
• Dies kann in der Zukunft geändert werden.
• Der Erreiche-Ziel-Status eines Humanoiden läuft nach 8 Sekunden ab, wenn er sein Ziel nicht erreicht.
• Dies wird getan, damit NPCs nicht darauf feststecken, auf Humanoid.MoveToFinished zu warten, um zu initiieren.
• Wenn du nicht möchtest, dass dies passiert, solltest du MoveTo wiederholt aufrufen, damit der Timeout immer wieder zurückgesetzt wird.

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)

Diese Methode fügt das angegebene Accessory dem übergeordnetes Teildes Humanoids an.

Wenn diese Methode aufgerufen wird, wird ein Accessory an den Charakter angehängt, indem nach einer Attachment im Elternteil des Humanoiden gesucht wird, die denselben Namen wie ein Attachment im Accessoirehat, Handle Part .Wenn einer gefunden wird, wird der Griff-Teil mit dem Elternteil des verbunden, indem ein verwendet wird, und die Schweißnaht so konfiguriert wird, dass die den gleichen Platzeinnimmt.

Wenn das erforderliche Attachment nicht gefunden werden kann, bleibt das Accessory dem Elternteil des Humanoids überlassen, aber es wird nicht angehängt.

In der Regel werden Zubehörschweißungen auf dem Server erstellt, aber sie können unter bestimmten Umständen auf dem Client erstellt werden.In diesen Situationen können clientseitige Anrufe bei AddAccessory() möglicherweise nicht immer das gewünschte Verhalten produzieren, und du kannst BuildRigFromAttachments() verwenden, um die erwartete Schöpfungzu erzwingen.

Parameter

Rückgaben

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)

Diese Methode montiert einen Baum von Motor6D Verbindungen für die Humanoid . Motor6D Verbindungen sind für die Wiedergabe von Animations erforderlich.

Beginnend mit dem humanoiden RootPart , sammelt diese Methode alle Attachments Eltern, die in dem aktuellen Teil mit RigAttachment benannt wurden.Dann sucht es nach einem passenden Anhang im Charakter, der den gleichen Namen wie die Anlage hat.Mit diesen beiden Anhängen wird ein gemeinsamer Motor6D auf der Grundlage der Teile, die mit den beiden Anhängen verbunden sind, und des CFrame der Anhänge erzeugt.

Humanoid:BuildRigFromAttachments() skaliert auch den charakter und legt körperfarben fest.

Rückgaben

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

Diese Methode verursacht, dass die Humanoid in den angegebenen Enum.HumanoidStateType eintreten, um die Aktivität zu beschreiben, die der Humanoid derzeit durchführt.

Bitte überprüfe die Enum.HumanoidStateType Seite für weitere Informationen zu den einzelnen Zuständen, da einige unintuitive Namen haben.Zum Beispiel beschreibt Enum.HumanoidStateType.Running einen Zustand, in dem die Beine des Humanoids auf dem Boden sind, einschließlich dann, wenn sie stillstehen.

Aufgrund des Standardverhaltens des Humanoid werden einige Zustände automatisch geändert, wenn sie festlegenwerden. Zum Beispiel:

• Die Einstellung des Zustands auf Enum.HumanoidStateType.Swimming, wenn der Humanoid nicht im Wasser ist, wird dazu führen, dass er automatisch auf Enum.HumanoidStateType.GettingUp gesetzt wird.
• Da es unbenutzt wird, wird die Festlegung des Zustands auf Enum.HumanoidStateType.PlatformStanding dazu führen, dass der menschliche Zustand automatisch auf Enum.HumanoidStateType.Running gesetzt wird.

Beachten Sie, dass, um den Zustand Humanoid mit dieser Methode festzulegen, Sie dies von einem LocalScript und der Client muss Netzwerkbesitz des Player.Character tun.Alternativ kannst du diese Methode von einer serverseitigen Script aus aufrufen, aber der Server muss Netzwerkbesitz für den Spielercharakter haben.

Siehe auch Humanoid:SetStateEnabled() um einen bestimmten Zustand zu aktivieren oder zu deaktivieren, und Humanoid:GetState() um den aktuellen humanoiden Zustand zu erhalten.

Parameter

Rückgaben

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)

Diese Methode macht die Humanoid den angegebenen Tool ausrüsten.

Das folgende Beispiel würde eine Player verursachen, um ein Werkzeug in Workspace mit dem Namen 'Werkzeug' auszustatten.

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

Wenn diese Methode aufgerufen wird, wird der Humanoid zuerst automatisch alle Tools ausrüsten, die es derzeit ausgerüstet hat.

Obwohl sie ausgerüstet werden, funktioniert nicht, wenn sie keinen Ziehpunkthaben, unabhängig davon, ob diese Methode verwendet wird, sie auszurüsten oder nicht.

Siehe auch:

• Um Werkzeuge abzulegen, verwende Humanoid:UnequipTools()

Parameter

Rückgaben

Diese Methode gibt eine Reihe von Accessory Objekten zurück, die der Elternteil des Humanoiden derzeit trägt.Alle solchen Accessory Objekte werden enthalten, unabhängig davon, ob sie angehängt sind oder nicht.

Wenn das Humanoid keine Accessory Objekte hat, wird eine leere Liste zurückgegeben.

Siehe auch Humanoid:AddAccessory() um einen Accessory einem menschlichen übergeordnetes Teileines Humanoids beizufügen.

Rückgaben

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)

Diese Methode gibt eine Kopie des zwischengespeicherten HumanoidDescription des Humanoiden zurück, die seinen aktuellen Look beschreibt.Dies kann verwendet werden, um den Look eines Charakters schnell zu bestimmen und seinen Look auf andere Charaktere mit der Humanoid:ApplyDescription()-Methode zuzuweisen.

Siehe auch

• Players:GetHumanoidDescriptionFromUserId() , die eine HumanoidDescription zurückgibt, die den avatar für den übergebenen benutzer beschreibt.
• Players:GetHumanoidDescriptionFromOutfitId() , die eine HumanoidDescription zurückgibt, deren parameter initialisiert werden, um denen des übergebenen serverseitigen objektzu entsprechen.
• Player:LoadCharacterWithHumanoidDescription() , die einen spieler mit dem look vom übergebenen HumanoidDescription spawnet.

Rückgaben

Diese Methode gibt zurück, was Enum.BodyPartR15 ein Part ist, oder Enum.BodyPartR15.Unknown wenn das Teil kein R15-Körperteil ist.Diese Methode ermöglicht es Entwicklern, Spieler-Körperteile unabhängig von den tatsächlichen Körperteilnamen abzurufen, anstatt eine Enumeration zurückzugeben.

Es kann in Verbindung mit Humanoid:ReplaceBodyPartR15() verwendet werden.Wenn zum Beispiel ein Körperteil eines Spieler:inetwas berührt, gibt diese Funktion eine Instanzzurück.Entwickler können dann nachsehen, welcher Teil des Körpers das war, wie Kopf oder Arm.Dann hängt es davon ab, was dieser Teil war, können Entwickler entweder eine Spielaktion ausführen oder diesen Teil durch einen anderen Teil ersetzen - vielleicht Schäden zeigen.

Diese Methode kann für Spiele nützlich sein, bei denen die Trefferposition wichtig ist.Zum Beispiel kann es verwendet werden, um zu bestimmen, ob ein Spieler im Bein getroffen wird und dann aufgrund der Verletzung verlangsamt wird.

Parameter

Rückgaben

Diese Methode gibt die Enum.Limb Enum zurück, die mit dem angegebenen Part verbunden ist. Sie funktioniert für R15- und R6-Rigs, zum Beispiel:

-- Für 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

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

Beachten Sie, dass Humanoid:GetLimb() einen Fehler wirft, wenn der Elternteil des Teils nicht auf den übergeordnetes Teildes Humanoiden eingestellt ist.

Parameter

Rückgaben

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

Rückgaben

Diese Methode gibt die aktuelle Enum.HumanoidStateType des Humanoiden zurück, die die Aktivität beschreibt, die der Humanoid derzeit durchführt, wie z. B. Springen oder Schwimmen.

Siehe auch Humanoid:SetStateEnabled() um einen bestimmten Zustand zu aktivieren oder zu deaktivieren, und Humanoid:ChangeState() um den aktuellen humanoiden Zustand zu ändern.

Rückgaben

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)

Die Methode GetStateEnabled gibt zurück, ob ein Enum.HumanoidStateType für das Humanoid aktiviert ist.

Der menschliche Zustand beschreibt die Aktivität, die der Menschoid derzeit durchführt.

Wenn ein bestimmtes Enum.HumanoidStateType deaktiviert ist, kann der Humanoid nie in diesen Zustand eintreten.Das gilt unabhängig davon, ob der Versuch, den Zustand zu ändern, mit Humanoid:ChangeState() oder Roblox-internem humanoidem Codesdurchgeführt wird.

Siehe auch:

• Für ein Ereignis, das ausgelöst wird, wenn ein humanoide Zustand aktiviert oder deaktiviert wird, siehe Humanoid.StateEnabledChanged
• Um einen Humanoid zu aktivieren oder zu deaktivieren Humanoid:SetStateEnabled()

Parameter

Rückgaben

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

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

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

Diese Methode verursacht, dass der Humanoid in die angegebene Vector3 Richtung geht.

Standardmäßig ist die Richtung in Bedingungen, aber wenn der relativeToCamera -Parameter true ist, ist die Richtung relativ zu der CFrame des CurrentCamera.Da die negative Richtung Z als "vorwärts" in Roblox betrachtet wird, wird der folgende Code den menschlichen Gang in Richtung der CurrentCamera machen.

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

Wenn diese Methode aufgerufen wird, bewegt sich die Humanoid, bis die Methode erneut aufgerufen wird.Diese Methode wird jedoch im nächsten Frame durch das Skript, das. PL: die Skriptsvon Roblox überschrieben.Dies kann vermieden werden, indem diese Funktion jedes Frame aufruft, indem verwendet wird (siehe Beispiel) oder die Kontrollskripte in überschrieben werden.

Diese Methode kann auf dem Server aufgerufen werden, aber dies sollte nur getan werden, wenn der Server Netzwerkbesitz der Montagemaschine des Humanoiden hat.

Siehe auch Humanoid:MoveTo(), was einen Humanoid Spaziergang zu einem Punkt macht, und Player:Move(), die diese Funktion effektiv aufruft.

Parameter

Rückgaben

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)

Diese Methode veranlasst die Humanoid zu versuchen, an den angegebenen Ort zu gehen, indem die Humanoid.WalkToPoint und Humanoid.WalkToPart Eigenschaften festgelegt werden.

Die Standort- und Teil-Parameter entsprechen dem, was Humanoid.WalkToPoint und Humanoid.WalkToPart festgelegt wird.

Wenn der Teil-Parameter angegeben wird, wird der Humanoid-Punkt immer noch erreicht.Wenn sich das Teil jedoch bewegt, dann wird der Punkt, der Humanoid gehen wird, an die gleiche Position im Verhältnis zum Teil verschoben.Wenn der Teil -Parameter nicht angegeben wird, ändert sich die Position, zu der der Humanoid geht, nicht.

Der Erreiche-Ziel-Status eines Humanoiden läuft nach 8 Sekunden ab, wenn er sein Ziel nicht erreicht.Dies wird getan, damit NPCs nicht darauf feststecken, auf Humanoid.MoveToFinished zu warten, um zu initiieren.Wenn du nicht möchtest, dass dies passiert, solltest du MoveTo wiederholt aufrufen, damit der Timeout immer wieder zurückgesetzt wird.

MoveTo() endet, wenn eine der folgenden bedingungen zutrifft:

• Der Charakter kommt an seinem Ziel an. Es gibt eine ~1-Stud-Schwelle, um verschiedene menschliche Geschwindigkeiten und Frameraten zu berücksichtigen.

• Der Charakter steckt fest und der achtsekündige Timer läuft ab.

• Der Wert von entweder Humanoid.WalkToPoint oder Humanoid.WalkToPart ändert sich.

• Ein Skript ruft Humanoid:Move() mit einem neuen moveDirection Parameter auf.

• Ein Skript ändert die Eigenschaft CFrame des RootPart.

Parameter

Rückgaben

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)

Diese Methode entfernt alle Accessory Objekte, die vom übergeordnetes Teildes Humanoids getragen werden. Für Spieler Characters wird dies alle Hüte und andere Accessoires entfernen.

Diese Methode entfernt Accessory Objekt, indem sie Instance:Destroy() auf sie aufruft, was bedeutet, dass die Parent der Zubehörteile auf nil festgelegt und gesperrt sind.

Siehe auch Humanoid:AddAccessory() um ein Accessory anzufügen, und Humanoid:GetAccessories() um alle Accessory Objekte zu erhalten, die einem Humanoid gehören.

Rückgaben

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)

Ersetzt dynamisch einen R15/Rthro-Teillimb in einem Humanoid durch einen anderen Teil. Der Teil wird automatisch wie üblich skaliert.

Diese Methode ist nützlich, um Charaktere während des Spiels zu modifizieren oder Charaktere aus einer Rigzu bauen.Die verwandte Methode GetBodyPartR15 kann nützlich sein, wenn Sie diese Methode verwenden.

Der Name des Teils, das übergeben wurde, sollte mit dem Namen des BodyPartR15 Enum übereinstimmen, das übergeben wurde.

Parameter

Rückgaben

Diese Methode legt fest, ob ein bestimmtes Enum.HumanoidStateType aktiviert ist für die Humanoid.Wenn ein bestimmtes Enum.HumanoidStateType deaktiviert ist, kann der Humanoid niemals in diesen Zustand gelangen.Das gilt unabhängig davon, ob der Versuch, den Zustand zu ändern, mit Humanoid:ChangeState() oder Roblox-internem Codesdurchgeführt wird.

Beachten Sie, dass die Verwendung von SetStateEnabled() auf dem Server die Änderung nicht an den Client oder umgekehrt repliziert.

Parameter

Rückgaben

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)

Diese Methode senkt die Humanoid.Health des Humanoid durch die angegebene Menge wenn es nicht durch eine ForceField geschützt wird

Diese Methode akzeptiert negative Werte für den Betrag-Parameter.Dies wird die Humanoiden Humanoid.Health erhöhen.Dies wird jedoch nur dann eine Auswirkung haben, wenn keine ForceField vorhanden ist.

Wie schützen ForceFields gegen TakeDamage

Ein gilt als geschützt, wenn ein eines der folgenden Kriterien erfüllt:

• Die ForceField teilt sich die gleiche Instance.Parent wie die Humanoid
• Die ForceField ist dem Humanoid.RootPart des Humanoid übergeordnet
• Die ForceField ist einem Vorfahren der Humanoid übergeordnet, außer der Workspace

Um Schaden an einem Humanoid zuzufügen, unabhängig von allen ForceFields vorhandenen, setze Humanoid.Health direkt.

Für weitere Informationen darüber, wie ForceFields schützen Humanoids siehe die Seite ForceField.

Parameter

Rückgaben

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)

Diese Methode entfernt jede Tool derzeit von der Humanoid ausgerüstet

Die nicht ausgerüstete Tool wird dem Backpack des Player zugewiesen, das mit dem Humanoid verbunden ist.

Wenn keine Tool ausgerüstet ist, tut diese Methode nichts.

Obwohl Tools von NPCs (Nichtspielercharakteren) ausgerüstet werden kann, funktioniert diese Methode nur auf Humanoids mit einem entsprechenden Player.Dies liegt daran, dass ein Backpack Objekt erforderlich ist, um das nicht ausgerüstete Tool zu paren.