Player

Das AccountAlter ist ein Player Eigenschaft, die beschreibt, wie lange das Konto eines Spielers vor Tagen registriert wurde.Es wird mit der Player:SetAccountAge()-Funktion festgelegt, auf die Skripte nicht zugreifen können.

Diese Eigenschaft ist nützlich, um neue Roblox-Spielerinhalte wie Tutorials konditionell anzuzeigen.

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- eine woche
local MIN_AGE_VETERAN = 365 -- ein jahr

-- Diese Funktion markiert einen Teil mit Text mit einem BillboardGui
local function mark(part, text)
	local bbgui = Instance.new("BillboardGui")
	bbgui.AlwaysOnTop = true
	bbgui.StudsOffsetWorldSpace = Vector3.new(0, 2, 0)
	bbgui.Size = UDim2.new(0, 200, 0, 50)
	local textLabel = Instance.new("TextLabel")
	textLabel.Size = UDim2.new(1, 0, 1, 0) -- Eltern füllen
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Zur Teil hinzufügen
	bbgui.Parent = part
	bbgui.Adornee = part
end

local function onPlayerSpawned(player, character)
	local head = character:WaitForChild("Head")
	if player.AccountAge >= MIN_AGE_VETERAN then
		mark(head, "Veteran Player")
	elseif player.AccountAge <= MAX_AGE_NEW_PLAYER then
		mark(head, "New Player")
	else
		mark(head, "Regular Player")
	end
end

local function onPlayerAdded(player)
	-- Höre auf, wenn dieser Spieler spawnen
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Die Eigenschaft AutoJumpEnabled bestimmt, ob das Player.Character eines Player mit einem mobilen Gerät automatisch springt, wenn es ein Hindernis trifft.Dies kann die Ebenen auf einem mobilen Gerät navigierbarer machen.

Wenn der Spieler dem Spiel beitritt, bestimmt der Wert StarterPlayer.AutoJumpEnabled den ursprünglichen Zustand dieser Eigenschaft.Dann legt diese Eigenschaft den Wert der Eigenschaft Humanoid.AutoJumpEnabled des Player.Character beim Spawn fest.Mit anderen Worten, es ist möglich, das Auto-Sprungverhalten auf einer pro-Zeichen-, pro-Spieler- und pro-Spiel-Basis mit diesen drei Eigenschaften einzustellen.

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 CameraMaxZoomDistance Player legt die maximale Entfernung in Studs fest, von der die Kamera vom Charakter mit den Standardkameras entfernt sein kann.

Mit anderen Worten, es kontrolliert die maximale Entfernung, auf die die Kamera des Spielers sich auszoomen lassen kann.

Der Standardwert dieser Eigenschaft wird von StarterPlayer.CameraMaxZoomDistance festgelegt.Wenn dieser Wert auf einen niedrigeren Wert als Player.CameraMinZoomDistance festgelegt wird, wird er auf CameraMinZoomDistance erhöht.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

Die Eigenschaft CameraMinZoonDistance Player legt die minimale Entfernung in Studs fest, von der die Kamera vom Charakter mit den Standardkameras entfernt sein kann.

Mit anderen Worten, es kontrolliert die minimale Entfernung, auf die die Kamera des Spielers sich zubewegen darf.

Der Standardwert dieser Eigenschaft wird von StarterPlayer.CameraMinZoomDistance festgelegt.Wenn dieser Wert auf einen höheren Wert als Player.CameraMaxZoomDistance festgelegt wird, wird er auf CameraMaxZoomDistance verringert.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

Die Eigenschaft Kameramodus legt den Kameramodus des Spielers fest, der standardmäßig auf die dritte Person eingestellt ist.

Dritte Person

Im Standard-Dritter-Person-Modus ( Enum.CameraMode.Classic ), kann der Charakter in der Kamera gesehen werden. Während in diesem Modus das Standardverhalten ist:

• Spieler können mit der rechten Maustaste klicken und ziehen (Maus), tippen und ziehen (Mobilgerät), den sekundären Thumbstick (Spielpad) verwenden oder die linken/rechten Pfeile (Tastatur) drücken, um die Kamera um ihren Charakter herum zu drehen.
• Wenn ein Spieler seinen Charakter bewegt, zeigt er in die entsprechende Bewegungsrichtung.
• Spieler können sich frei ein- und auszoomen, sogar bis zur ersten Person bei vollem Zoom.

Erste Person

Im First-Person-Modus ( Enum.CameraMode.LockFirstPerson ), ist die Kamera des Spielers so weit wie möglich herangezoomt.Es sei denn, es gibt eine sichtbare GUI mit der Eigenschaft GuiButton.Modal , die auf true gesetzt ist, bewegt die Maus, zieht auf dem Handy oder verwendet den sekundären Daumenstick auf einem Gamepad, wird die Kamera um den Charakter herum gedreht.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMode = Enum.CameraMode.LockFirstPerson

Die Eigenschaft CanLoadCharacterAppearance Player bestimmt, ob das Aussehen des Charakters geladen wird, wenn der Spieler erscheint.Der Standardwert dieser Eigenschaft wird von StarterPlayer.LoadPlayerAppearance festgelegt.

Wenn wahr , wird der Charakter das Aussehen des Spielers laden, das dem Spielern entspricht Player.CharacterAppearanceId .

Wenn falsch , wird der Spieler mit einem Standardaussehen spawnen - ein graues Charaktermodell ohne Hüte, Hemden, Hosen usw.

Wenn du die Eigenschaft setzt, nachdem der Charakter gespawnt wurde, ändert sich der Charakter nicht, du musst Player:LoadCharacter() anrufen, um das neue Aussehen zu laden.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CanLoadCharacterAppearance = false

Die Eigenschaft Zeichen enthält einen Verweis auf einen Model, der einen Humanoid und Körperteile, Skripte und andere Objekte enthält, die für die Simulation des Avatars des Spielers in Erfahrung erforderlich sind.Das Modell wird dem Workspace übergeordnet, kann aber verschoben werden.Es wird automatisch geladen, wenn Players.CharacterAutoLoads ist true und es kann manuell geladen werden, sonst mit Player:LoadCharacter().

Anfangs ist diese Eigenschaft nil und sie wird festgelegt, wenn der Charakter des Spielers zum ersten Mal erscheint.Verwende das Player.CharacterAdded-Ereignis, um zu erkennen, wann der Charakter eines Spielers richtig geladen wird, und das Player.CharacterRemoving-Ereignis, um zu erkennen, wann der Charakter despawnen soll.Vermeiden Sie die Verwendung von Object:GetPropertyChangedSignal() auf dieser Eigenschaft.

Beachten Sie, dass diejenigen, die von > oder > in einen Spielerspiel > oder > kopiert werden, oft vor dem Ersetzen des alten Charaktermodells ausgeführt werden, so dass > sich auf das alte Modell beziehen kann, dessen Eigenschaft Eigenschaft ist.Daher ist es in einem LocalScript unter StarterGui oder StarterPack ratsam, sicherzustellen, dass der Elternteil von Charakter nicht nil ist, bevor es verwendet wird, zum Beispiel:

local Players = game:GetService("Players")
local player = Players.LocalPlayer

local character = player.Character
if not character or character.Parent == nil then
	character = player.CharacterAdded:Wait()
end

Diese Eigenschaft legt die Benutzer-ID des Kontos fest, dessen Charakteraussehen für das character.Standardmäßig ist diese Eigenschaft die Player.UserId, die den Avatar des Spielers verwendet, wie er ihn auf der Roblox-Website erstellt hat.

Das Ändern dieser Eigenschaft auf die Benutzer-ID eines anderen Kontos veranlasst den Spieler mit dem Aussehen dieses Kontos zu spawnen (Hüte, Hemd, Hosen usw.).

Spiele können auch umschalten, ob der Charakter eines Spielers im Spiel geladen wird oder nicht, indem sie die Eigenschaft StarterPlayer.LoadCharacterAppearance ändern.

local Players = game:GetService("Players")

local disguiseCommand = "/disguise "

local function onPlayerChatted(player, message)
	if message:sub(1, disguiseCommand:len()):lower() == disguiseCommand:lower() then
		local input = message:sub(disguiseCommand:len() + 1)
		local id = tonumber(input)
		if not id then -- Die Zahl konnte nicht analysiert werden, vielleicht haben sie stattdessen einen Benutzernamen eingegeben
			pcall(function() -- Dieser Anruf kann manchmal fehlschlagen!
				id = Players:GetUserIdFromNameAsync(input) -- ID aus Name abrufen
			end)
		end
		if id then
			-- Zeichenaussehen festlegen und dann respawnen
			player.CharacterAppearanceId = id
			player:LoadCharacter()
		else
			-- Wir konnten keine ID von ihrer Eingabe erhalten
		end
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Legt fest, wie die Standard-Kamera-Skripte Objekte zwischen der Kamera und dem Kamerathema handhaben.Von StarterPlayer.DevCameraOcclusionMode und kann für einzelne Spieler nicht geändert werden.

Der Standardwert ist Zoom (0). Siehe Enum.DevCameraOcclusionMode für eine Liste der verfügbaren Modi.

Die Eigenschaft DevComputerCameraMode legt fest, wie ein Spieler seine Kamera bewegt, wenn er ein Gerät mit Maus und Tastatur verwendet.Siehe Enum.DevComputerCameraMovementMode für eine Beschreibung jedes verfügbaren Kamerasteuerungsmodus.Dieses Eigenschaft kann nicht mit einem LocalScript (es muss auf dem Server mit einem Script festgelegt werden).

Der Standardwert dieser Eigenschaft wird von StarterPlayer.DevComputerCameraMovementMode bestimmt.

Das Wort "Computer" in diesem Eigenschaftsnamen bezieht sich auf nicht-TouchEnabled , nicht-GamepadEnabled Geräte.

Wenn auf Benutzerauswahl eingestellt, kann ein Spieler während des Spiels aus jedem Steuerungsmodus (außer Skriptbar ) in den Einstellungen des Erlebnisses wählen.Im Allgemeinen ist es eine gute Idee, Spielern zu ermöglichen, ihren Steuerungsmodus zu wählen, um die Zugänglichkeit zu maximieren.

Es ist möglich, ein benutzerdefiniertes Steuerschema zu erstellen, indem diese Eigenschaft auf Skriptbar gesetzt wird.

Diese Eigenschaft wirkt sich nicht auf Spieler aus, die ein Gerät mit aktiviertem Touch verwenden. Siehe stattdessen Player.DevTouchCameraMode.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Set the player's camera movement mode on computers to classic
player.DevComputerCameraMode = Enum.DevComputerCameraMovementMode.Classic

Die Eigenschaft DevComputerMovementMode legt fest, wie ein Spieler seinen Charakter bewegt, wenn er ein Gerät mit Maus und Tastatur verwendet.Siehe Enum.DevComputerMovementMode für eine Beschreibung jedes verfügbaren Bewegungssteuerungsmodus.Dieses Eigenschaft kann nicht mit einem LocalScript (es muss auf dem Server mit einem Script festgelegt werden).

Der Standardwert dieser Eigenschaft wird von StarterPlayer.DevComputerMovementMode bestimmt.

Das Wort "Computer" in diesem Eigenschaftsnamen bezieht sich auf nicht-TouchEnabledGeräte.

Wenn auf Benutzerauswahl eingestellt, kann ein Spieler während des Spiels aus jedem Steuerungsmodus (außer Skriptbar ) in den Einstellungen des Erlebnisses wählen.Im Allgemeinen ist es eine gute Idee, Spielern zu ermöglichen, ihren Steuerungsmodus zu wählen, um die Zugänglichkeit zu maximieren.

Es ist möglich, ein benutzerdefiniertes Steuerschema zu erstellen, indem diese Eigenschaft auf Skriptbar gesetzt wird.

Diese Eigenschaft wirkt sich nicht auf Spieler aus, die ein touchfähiges Gerät verwenden. Siehe stattdessen Player.DevTouchMovementMode.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	-- Set the player's movement mode on desktop devices to click-to-move
	-- Once set, the player can right click in the game world and the character will move there.
	player.DevComputerMovementMode = Enum.DevComputerMovementMode.ClickToMove
end

Players.PlayerAdded:Connect(onPlayerAdded)

Diese Eigenschaft bestimmt, ob ein Spieler die Mouse-Sperre umschalten kann, indem er Shift drückt.Ein Spieler kann den Maus-Sperrschalter in den Einstellungen der Erfahrung während des Spiels deaktivieren.Standardmäßig wird diese Eigenschaft auf den Wert von StarterPlayer.EnableMouseLockOption festgelegt.Dies kann auf serverseitig während der Laufzeit durch Verwendung eines Script festgelegt werden.Es kann nicht auf clientseitig festgelegt werden.

Wenn die Mausverriegelung aktiviert ist, wird der Cursor des Spielers in der Mitte des Bildschirms gesperrt.Das Bewegen der Maus wird die Kamera um den Spieler herum character orbitieren, und der Charakter wird in die gleiche Richtung wie die camera gehen.Es kompensiert auch die Kameraansicht direkt über der rechten Schulter des Charakters des Spielers.

Beachte, dass API-Schnittstellen, die Shift-Lock verwenden, im Prozess sind, veraltet zu werden, daher wird empfohlen, stattdessen UserInputService.MouseBehavior zu verwenden, um die Maus zu sperren.

local Players = game:GetService("Players")

local function toggleMouseLock(player)
	player.DevEnableMouseLock = not player.DevEnableMouseLock
	if player.DevEnableMouseLock then
		print("Mouse lock is available")
	else
		print("Mouse lock is not available")
	end
end

local function onPlayerChatted(player, message, _recipient)
	if message == "mouselock" then
		toggleMouseLock(player)
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Die DevTouchCameraMode-Eigenschaft legt fest, wie ein Spieler seine Kamera bewegt, wenn er ein TouchEnabled verwendet.Siehe Enum.DevTouchCameraMovementMode für eine Beschreibung jedes verfügbaren Kamerasteuerungsmodus.Dieses Eigenschaft kann nicht mit einem LocalScript (es muss auf dem Server mit einem Script festgelegt werden).

Der Standardwert dieser Eigenschaft wird von StarterPlayer.DevTouchCameraMovementMode bestimmt.

Wenn auf Benutzerauswahl eingestellt, kann ein Spieler während des Spiels aus jedem Steuerungsmodus (außer Skriptbar ) in den Einstellungen des Erlebnisses wählen.Im Allgemeinen ist es eine gute Idee, Spielern zu ermöglichen, ihren Steuerungsmodus zu wählen, um die Zugänglichkeit zu maximieren.

Es ist möglich, ein benutzerdefiniertes Steuerschema zu erstellen, indem diese Eigenschaft auf Skriptbar gesetzt wird.

Diese Eigenschaft wirkt sich nicht auf Spieler aus, die kein touch-aktiviertes Gerät verwenden. Siehe stattdessen Player.DevComputerCameraMovementMode.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

-- Set the player's camera movement mode on mobile devices to classic
player.DevTouchCameraMovementMode = Enum.DevTouchCameraMovementMode.Classic

Die Eigenschaft DevTouchMovementMode legt fest, wie ein Spieler seinen Charakter bewegt, wenn er ein TouchEnabled verwendet.Siehe Enum.DevTouchMovementMode für eine Beschreibung jedes verfügbaren Bewegungssteuerungsmodus.Dieses Eigenschaft kann nicht mit einem LocalScript (es muss auf dem Server mit einem Script festgelegt werden).

Der Standardwert dieser Eigenschaft wird von StarterPlayer.DevTouchMovementMode bestimmt.

Wenn auf Benutzerauswahl eingestellt, kann ein Spieler während des Spiels aus jedem Steuerungsmodus (außer Skriptbar ) in den Einstellungen des Erlebnisses wählen.Im Allgemeinen ist es eine gute Idee, Spielern zu ermöglichen, ihren Steuerungsmodus zu wählen, um die Zugänglichkeit zu maximieren.

Es ist möglich, ein benutzerdefiniertes Steuerschema zu erstellen, indem diese Eigenschaft auf Skriptbar gesetzt wird.

Diese Eigenschaft wirkt sich nicht auf Spieler aus, die kein touch-aktiviertes Gerät verwenden. Siehe stattdessen Player.DevComputerMovementMode.

local Players = game:GetService("Players")

game.Players.PlayerAdded:Connect(function(player)
	-- Set the player's movement mode on mobile devices to a dynamic thumbstick
	player.DevTouchMovementMode = Enum.DevTouchMovementMode.DynamicThumbstick
end)

Die DisplayName ist eine Player Eigenschaft, die den Anzeigennamen des authentifizierten Benutzers enthält, der mit dem Player Objekt verbunden ist.Im Gegensatz zu Benutzernamen sind Display-Namen nicht eindeutige Namen, die ein Spieler anderen anzeigt.Wenn der Roblox-Benutzer keine gewählt hat, liest die Eigenschaft dasselbe wie die Eigenschaft Name.

Hinweis:

• Da Display-Namen nicht einzigartig sind, ist es möglich, dass zwei Spieler in einer einzigen Instanz identische Namen haben.Wenn du einen global einzigartigen Identifikator für einen Spieler benötigst, verwende stattdessen Player.UserId (statisch) oder Player.Name (der aktuelle Benutzername).
• Zeichen, die mit Player.LoadCharacter oder von der Roblox-Engine erstellt wurden, erhalten ihre Humanoid.DisplayName Eigenschaft auf die Player.DisplayName Eigenschaft zugewiesen.
• Anzeigennamen können Zeichen der Unicode im String enthalten. Siehe UTF-8 für weitere Informationen darüber, wie mit Zeichen der Unicode in Zeichenketten gearbeitet wird.

Die FollowUserId ist eine Player Eigenschaft, die das Player.UserId des Benutzers enthält, dem ein Spieler in das Spiel gefolgt ist.Wenn der Spieler niemandem in das Spiel folgte, wird diese Eigenschaft 0 sein.Diese Eigenschaft ist nützlich, um Spieler zu warnen, die von einem anderen Spieler in das Spiel verfolgt wurden.

Du kannst den Namen des Spielers erhalten, der mit dieser Benutzer-ID und der Players:GetNameFromUserIdAsync()-Funktion verfolgt wird.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local screenGui = Instance.new("ScreenGui")
screenGui.Parent = player:WaitForChild("PlayerGui")

local function onPlayerAdded(newPlayer)
	if newPlayer.FollowUserId == player.UserId then
		local textLabel = Instance.new("TextLabel")
		textLabel.Parent = screenGui
		textLabel.Text = "You were followed to this game by " .. newPlayer.Name .. "!"
		task.delay(3, function()
			if textLabel then
				textLabel:Destroy()
			end
		end)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

Die Eigenschaft GameplayPaused zeigt an, ob der Spieler derzeit in einem Pausenzustand an einem Ort mit StreamingEnabled aktiviert ist.Es wird auf dem Client festgelegt, wird aber auf den Server repliziert.Um den Pausenstatus zu bestimmen, kannst du diese Eigenschaft verwenden.

Siehe auch:

• Workspace.StreamingEnabled, das kontrolliert, ob der inhaltstreaming aktiviert ist
• Workspace.StreamingIntegrityMode und Enum.StreamingIntegrityMode für weitere details darüber, wann das spiel pausiert wird.

Die Eigenschaft HasVerifiedBadge Player zeigt an, ob der Spieler ein verifiziertes Abzeichen hat.

Die Eigenschaft HealthDisplayDistance Player legt die Entfernung in Studs fest, auf der dieser Spieler andere Humanoid Gesundheitsbalken sehen wird.Wenn auf 0 gesetzt, werden die Gesundheitsbalken nicht angezeigt.Diese Eigenschaft wird standardmäßig auf StarterPlayer.HealthDisplayDistance festgelegt.

Wenn die Gesundheitsleiste eines Humanoids sichtbar ist, kannst du den Anzeigetyp mit Humanoid.DisplayDistanceType festlegen.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

Die Eigenschaft LocaleId Player zeigt die lokale ID an, die der lokale Spieler für seinen Roblox-Konto eingestellt hat.Es enthält eine Zeichenkette mit dem zweistelligen Code (zum Beispiel "en-us") für die lokale Sprache.

Dies kann verwendet werden, um die geografische Demografie der Spielerbasis deines Spiels zu bestimmen, und ist auch die Region, die für die automatische Lokalisierung von In-Experience-Inhalten verwendet wird (siehe GuiBase2d.AutoLocalize ).Diese Eigenschaft ermöglicht den Zugriff auf das lokale des Spielers vom Server aus.

Siehe auch LocalizationService.RobloxLocaleId , die lokale ID, die für die Lokalisierung interner Inhalte verwendet wird.Dies wird ein anderer Wert sein, wenn Roblox den lokalen Set-Lokalen des lokalen Spielers noch nicht intern unterstützt.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

print(player.LocaleId)

Dieses Eigenschaft kann nur gelesen werden, um die Mitgliedschaft zu bestimmen (es kann nicht auf einen anderen Mitgliedschaftstyp festgelegt werden).Es enthält ein Enum.MembershipType Enum des Mitgliedstyps des Kontos.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.MembershipType == Enum.MembershipType.Premium then
	-- Tun Sie etwas speziell für Premium-Mitglieder
end

Die Eigenschaft NameDisplayDistance StarterPlayer legt die Entfernung in Studs fest, auf der dieser Spieler andere Humanoid Namen sehen wird.Wenn die Eigenschaft auf 0 gesetzt ist, werden Namen versteckt.Diese Eigenschaft wird standardmäßig auf StarterPlayer.NameDisplayDistance festgelegt.

Wenn die Gesundheitsleiste eines Humanoids sichtbar ist, kannst du den Anzeigetyp mit Humanoid.DisplayDistanceType festlegen.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

Die Neutrale Eigenschaft bestimmt, ob der Spieler in einem bestimmten Team ist.

• Wenn true, ist der Spieler nicht in einem bestimmten Team.Dies bedeutet auch, dass die Eigenschaft weiß sein wird und die weiß sein wird.
• Wenn falsch , ist der Spieler in einem bestimmten Team.Die Eigenschaft wird dem entsprechen, auf dem sich der Spieler befindet, ebenso wie die .

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.Neutral then
	print("Player is neutral!")
else
	print("Player is not neutral!")
end

Eine nur lesbare Zeichenkette, die die Gruppe identifiziert, zu der der Spieler derzeit im Erlebnis gehört.Wenn der Spieler nicht in einer Gruppe ist, ist dieser Wert eine leere Zeichenfolge.

Dieses Eigenschaft ist für die Integration mit der Roblox-Party-Funktion unerlässlich.Verwende es in Kombination mit SocialService:GetPlayersByPartyId() und SocialService:GetPartyAsync(), um Informationen über die Party eines Spielers und seine Mitglieder zu erhalten.

Beachten Sie, dass dieser Service während des Spieltests in Roblox Studio nicht funktioniert; um Aspekte Ihrer Erfahrung mit ihm zu testen, müssen Sie die Erfahrung veröffentlichen und sie im Roblox-Anwendungsprogramm spielen.

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	local partyId = player.PartyId

	if partyId ~= "" then
		print("Player is in a party with ID: " .. partyId)
	else
		warn("Player is not in a party")
	end
end)

Der ReplicationFocus Player Eigenschaft legt das Teil fest, auf die die Replikation konzentriert wird, um sich um einen Spieler herum.Verschiedene Roblox-Systeme, die über das Netzwerk kommunizieren (z. B. Physik, Streaming usw.), replizieren sich mit unterschiedlichen Geschwindigkeiten, abhängig davon, wie nah Objekte zum Replikationsfokus sind.

Wenn diese Eigenschaft nil ist, kehrt sie zu ihrem Standardverhalten zurück, das darin besteht, den Charakter des lokalen Spielers als Replikationsschwerpunkt zu behandeln PrimaryPart.

Diese Eigenschaft sollte nur auf dem Server mit einem Script festgelegt werden, nicht mit einem LocalScript.Beachten Sie, dass diese Eigenschaft nicht die Netzwerkbesitzschaft von Teilen ändert oder aktualisiert.

local Players = game:GetService("Players")

local PLAYER_NAME = "polarpanda16"

local player = Players:WaitForChild(PLAYER_NAME)

local part = Instance.new("Part")
part.Parent = workspace
part.Name = "ReplicationFocusPart"
part.Anchored = true
player.ReplicationFocus = part

Wenn festgelegt, wird der Spieler bei der angegebenen SpawnLocation wiederbelebt.Dieses Eigenschaft kann nur über Luau festgelegt werden und muss einen Verweis auf eine gültige SpawnLocation enthalten, die die folgenden Kriterien erfüllen muss:

• Abkömmling von Workspace
• SpawnLocation.TeamColor ist auf Player.TeamColor oder SpawnLocation.Neutral ist auf wahr gesetzt

Wenn RespawnLocation nicht auf eine gültige SpawnLocation festgelegt ist, wird die Standard-Spawn-Logik angewendet.Für weitere Informationen zu diesem siehe die Seite für SpawnLocation .

Alternativen für RespawnLocation

• Ein Player wird aus SpawnLocations ihres Teams hervorgehen. In einigen Fällen kann es einfacher sein, stattdessen die Player.Team des Spielers zu ändern.
• Implementiere deine eigene benutzerdefinierte Spawn-Logik mit PVInstance:PivotTo(), um den Player.Character manuell zu bewegen.

local Players = game:GetService("Players")

local function addSpawn(spawnLocation)
	-- listen for the spawn being touched
	spawnLocation.Touched:Connect(function(hit)
		local character = hit:FindFirstAncestorOfClass("Model")
		if character then
			local player = Players:GetPlayerFromCharacter(character)
			if player and player.RespawnLocation ~= spawnLocation then
				local humanoid = character:FindFirstChildOfClass("Humanoid")
				-- make sure the character isn't dead
				if humanoid and humanoid:GetState() ~= Enum.HumanoidStateType.Dead then
					print("spawn set")
					player.RespawnLocation = spawnLocation
				end
			end
		end
	end)
end

local firstSpawn

-- look through the workspace for spawns
for _, descendant in pairs(workspace:GetDescendants()) do
	if descendant:IsA("SpawnLocation") then
		if descendant.Name == "FirstSpawn" then
			firstSpawn = descendant
		end
		addSpawn(descendant)
	end
end

local function playerAdded(player)
	player.RespawnLocation = firstSpawn
end

-- listen for new players
Players.PlayerAdded:Connect(playerAdded)

-- go through existing players
for _, player in pairs(Players:GetPlayers()) do
	playerAdded(player)
end

Die Eigenschaft Team ist ein Verweis auf ein Team Objekt innerhalb des Teams Dienstes.Es bestimmt das Team, auf dem sich der Spieler befindet; wenn das Player nicht in einem Team ist oder ein ungültiges Player.TeamColor hat, ist diese Eigenschaft nil .Wenn diese Eigenschaft festgelegt ist, ist der Spieler dem Team und dem Team.PlayerAdded Ereignis beigetreten, das auf das zugeordnete Team fällt.Ebenso feuert Team.PlayerRemoved , wenn die Eigenschaft von einem bestimmten Team ungesetzt wird.

local Players = game:GetService("Players")
local Teams = game:GetService("Teams")

local teamPlaying = Teams.Playing
local teamSpectators = Teams.Spectating

local playCommand = "/play"

local function play(player)
	player.Team = teamPlaying
	player.TeamColor = teamPlaying.TeamColor
	-- Respawn the player (moves them to spawn location)
	player:LoadCharacter()
end

local function onPlayerDied(player, _character)
	-- When someone dies, put them on the spectator team
	player.Team = teamSpectators
end

local function onPlayerSpawned(player, character)
	local human = character:WaitForChild("Humanoid")
	human.Died:Connect(function()
		onPlayerDied(player, character)
	end)
end

local function onPlayerChatted(player, message)
	if message:sub(1, playCommand:len()):lower() == playCommand then
		play(player)
	end
end

local function onPlayerAdded(player)
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
	player.Chatted:Connect(function(message, _recipient)
		onPlayerChatted(player, message)
	end)
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")
local Teams = game:GetService("Teams")

-- Command to choose a team (note the trailing space)
local joinCommand = "/jointeam "

local function findTeamByName(name)
	-- First, check for the exact name of a team
	if Teams:FindFirstChild(name) then
		return Teams[name]
	end
	-- Let's check for case-insensitive partial matches, like "red" for "Red Robins"
	for _, team in pairs(Teams:GetChildren()) do
		if team.Name:sub(1, name:len()):lower() == name:lower() then
			return team
		end
	end
	-- If we get to this point, no team matched the one we were looking for :(
end

local function onPlayerChatted(player, message, _recipient)
	-- Note: string.sub(message, ...) is the same as message:sub(...)
	if message:sub(1, joinCommand:len()):lower() == joinCommand:lower() then
		-- Matched "/JOINTEAM xyz" to our join command prefix "/jointeam "
		local teamName = message:sub(joinCommand:len() + 1) -- Cut out the "xyz" from "/jointeam xyz"
		local team = findTeamByName(teamName)
		if team then
			-- Set the team!
			player.Team = team
			player.Neutral = false
		else
			-- Tell the player that team could not be found :(
			player.Team = nil
			player.Neutral = true
		end
	end
end

local function onPlayerAdded(player)
	player.Chatted:Connect(function(...)
		onPlayerChatted(player, ...)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Die Eigenschaft TeamColor bestimmt, welchem Team ein Spieler zugeordnet ist, entsprechend dem Team.TeamColor des Teams.Das Ändern dieser Eigenschaft wird sich auf Player.Team, je nachdem, welches Team die gleiche BrickColor für seine Team.TeamColor hat.Wenn kein Teamobjekt die zugeordnete Teamfarbe hat, wird der Spieler keinem Team zugeordnet.

Es ist oft eine bessere Idee, Player.Team auf die jeweilige Team zu setzen, anstatt diese Eigenschaft zu verwenden.Das Festlegen dieser Eigenschaft führt oft zu Wiederholung desselben BrickColor-Werts für ein bestimmtes Team über viele Skripte; das ist etwas, das du vermeiden möchtest, wenn du dem Prinzip "Don't Repeat Yourself" (DRY) beitrittst.

local Players = game:GetService("Players")
local Teams = game:GetService("Teams")

local teamPlaying = Teams.Playing
local teamSpectators = Teams.Spectating

local playCommand = "/play"

local function play(player)
	player.Team = teamPlaying
	player.TeamColor = teamPlaying.TeamColor
	-- Respawn the player (moves them to spawn location)
	player:LoadCharacter()
end

local function onPlayerDied(player, _character)
	-- When someone dies, put them on the spectator team
	player.Team = teamSpectators
end

local function onPlayerSpawned(player, character)
	local human = character:WaitForChild("Humanoid")
	human.Died:Connect(function()
		onPlayerDied(player, character)
	end)
end

local function onPlayerChatted(player, message)
	if message:sub(1, playCommand:len()):lower() == playCommand then
		play(player)
	end
end

local function onPlayerAdded(player)
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
	player.Chatted:Connect(function(message, _recipient)
		onPlayerChatted(player, message)
	end)
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

Die Benutzer-ID ist ein Player Eigenschaft, die einen lesbaren Ganzzahl enthält, der eindeutig und konsistent jedes Benutzerkonto auf Roblox kennzeichnet.Im Gegensatz zum Instance.Name eines Spielers, der sich nach dem aktuellen Benutzernamen des Benutzers ändern kann, wird dieser Wert für denselben Account nie ändern.

Diese Eigenschaft ist bei der Speicherung/Ladung von Spielerdaten mit GlobalDataStores unerlässlich.Verwende die Benutzer-ID eines Spielers als Datenlagerschlüssel, damit jeder Spieler einen einzigartigen Schlüssel hat.

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print(player.UserId)
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local player = Players:GetPlayerByUserId(1)

if player then
	print("Player with userId 1 is in this server! Their name is: " .. player.Name)
else
	print("Player with userId 1 is not in this server!")
end

local BadgeService = game:GetService("BadgeService")
local Players = game:GetService("Players")

local OWNER_ID = 212423 -- can use game.CreatorId for published places
local BADGE_ID = 1

local ownerInGame = false

local function playerAdded(newPlayer)
	if newPlayer.UserId == OWNER_ID then
		-- if new player is the owner, set ownerInGame to true and give everyone the badge
		ownerInGame = true
		for _, player in pairs(Players:GetPlayers()) do
			-- don't award the owner
			if player ~= newPlayer then
				BadgeService:AwardBadge(player.UserId, BADGE_ID)
			end
		end
	elseif ownerInGame then
		-- if the owner is in the game, award the badge
		BadgeService:AwardBadge(newPlayer.UserId, BADGE_ID)
	end
end

local function playerRemoving(oldPlayer)
	if oldPlayer.UserId == OWNER_ID then
		ownerInGame = false
	end
end

Players.PlayerAdded:Connect(playerAdded)
Players.PlayerRemoving:Connect(playerRemoving)

local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")

local goldDataStore = DataStoreService:GetDataStore("Gold")

local STARTING_GOLD = 100

local function onPlayerAdded(player)
	local playerKey = "Player_" .. player.UserId

	local leaderstats = Instance.new("IntValue")
	leaderstats.Name = "leaderstats"

	local gold = Instance.new("IntValue")
	gold.Name = "Gold"
	gold.Parent = leaderstats

	local success, result = pcall(function()
		return goldDataStore:GetAsync(playerKey) or STARTING_GOLD
	end)
	if success then
		gold.Value = result
	else
		-- Failed to retrieve data
		warn(result)
	end

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)

Parameter

Rückgaben

Die Funktion ClearCharacterAppearance entfernt alle Accessory , Shirt, Pants, CharacterMesh und BodyColors vom angegebenen Spieler Player.Character.Darüber hinaus entfernt es auch das T-Shirt Decal auf dem Torso des Spielers.Die Körperteile und das Gesicht des Charakters bleiben unverändert.Diese Methode tut nichts, wenn der Spieler keinen Charakter hat.

Es entfernt nicht t-shirts , Kopfnetze oder Gesichter.

Rückgaben

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local character = player.Character or player.CharacterAdded:Wait()

local function onChildRemoved(child)
	print(child.ClassName, "removed from character")
end

character.ChildRemoved:Connect(onChildRemoved)

player:ClearCharacterAppearance()
--> BodyColors removed from character
--> ShirtGraphic removed from character
--> Shirt removed from character
--> Pants removed from character
--> CharacterMesh removed from character
--> Hat removed from character
--> Shirt removed from character

Die Funktion DistanceFromCharacter Player gibt die Entfernung zwischen dem Kopf des Charakters und dem angegebenen Vector3 Punkt zurück.Es gibt 0 zurück, wenn der Spieler keine Player.Character hat.

Dies ist nützlich bei der Bestimmung der Entfernung zwischen einem Spieler und einem anderen Objekt oder einer anderen Position im Spiel.

Wenn du die Entfernung zwischen zwei nicht-spielerischen Instanzen oder Positionen bestimmen möchtest, kannst du Folgendes verwenden:

local distance = (position1 - position2).Magnitude

Parameter

Rückgaben

local Players = game:GetService("Players")

for _, player in pairs(Players:GetPlayers()) do
	print(player:DistanceFromCharacter(Vector3.new(0, 0, 0)))
end

Gibt ein Wörterbuch zurück, das Informationen enthält, wie der Spieler sich der Erfahrung anschließt. Das Wörterbuch enthält eines der folgenden Felder:

<th>Wert-Typ</th>

    <th>Beschreibung</th>
  </tr>
</thead>

<tbody>
  <tr>
    <th>QuellenspielID</th>

    <td>zahl</td>

    <td>Die <code>Class.DataModel.GameId</code> des Erlebnisses, von dem der <code>Spieler</code> teleportiert wurde.Nur vorhanden, wenn der Spieler sich in die aktuelle Erfahrung teleportiert und wenn ein Server die Teleportfunktion aufruft.</td>
  </tr>

  <tr>
    <th>Quellplatz-ID</th>

    <td>zahl</td>

    <td>Die <code>Class.DataModel.PlaceId</code> des Ortes, von dem der <code>Spieler</code> teleportiert wurde.Nur vorhanden, wenn der Spieler sich zum aktuellen Ort teleportiert und ein Server die Teleportfunktion aufruft.</td>
  </tr>

  <tr>
    <th>Referiert von PlayerId</th>

    <td>zahl</td>

    <td>Die <code>Class.Player.UserId</code> des Spielers, der den aktuellen Spieler in das Erlebnis eingeladen hat.Verwende diese Daten, um den Referrer zu identifizieren und die Belohnungslogik auszulösen.</td>
  </tr>

  <tr>
    <th>Mitglieder</th>

    <td>zeichenkette</td>

    <td>Ein Array, das die <code>Class.Player.UserId</code> -Nummern der Benutzer enthält, die neben dem <code>Spieler</code> teleportiert wurden.Nur vorhanden, wenn der Spieler als Teil einer Gruppe teleportiert wurde.</td>
  </tr>

  <tr>
    <th>TeleportDaten</th>

    <td>variante</td>

    <td>Widerspiegelt die <code>teleportData</code>, die im ursprünglichen Teleport angegeben wurde.Nützlich für den Austausch von Informationen zwischen Servern, zu denen sich der Spieler teleportiert.Nur vorhanden, wenn <code>teleportData</code> angegeben wurde und ein Server die Teleportfunktion aufruft.</td>
  </tr>

  <tr>
    <th>Startdatum</th>

    <td>schnur</td>

    <td>Eine einfache oder JSON-codierte Zeichenkette, die Startdaten enthält, die in einer <a href="/production/promotion/deeplinks">tieferen Verknüpfung</a> URL oder <code>Class.ExperienceInviteOptions.LaunchData</code> angegeben sind.</td>
  </tr>

  <tr>
    <th>Spielbeitrittskontext</th><td>Wörterbuch</td>

    <td>
      Ein Wörterbuch, das relevante Informationen enthält, basierend auf dem Kontext des Spielbeitritts. Es enthält die folgenden Schlüssel:

      <ul>
        JoinSource : Enum.JoinSource ItemType : optional Enum.AvatarItemType > AssetId : optional string > OutfitId : optional string > AssetType : optional Enum.AssetType > AssetId : optional string >
      </ul>
    </td>
  </tr>
</tbody>

GetJoinData und TeleportData

Wenn ein Server den Teleport des Spielers initiiert, enthält das Wörterbuch, das diese Methode zurückgibt, die Teleportdaten des Spielers.Die Methode Player:GetJoinData() kann nur verwendet werden, um Teleportdaten auf dem Server abzurufen.Um die Daten auf dem Client abzurufen, verwende TeleportService:GetLocalPlayerTeleportData().

Im Gegensatz zu TeleportService:GetLocalPlayerTeleportData() bietet Player:GetJoinData() nur Teleportdaten, die den folgenden Sicherheitskriterien entsprechen:

• Es ist garantiert, dass es von einem Roblox-Server in den letzten 48 Stunden gesendet wurde.
• Es ist garantiert, mit diesem Player verschickt worden zu sein.
• Die SourcePlaceId und SourceGameId sind garantiert der Ort und das Universum, von dem die Daten gesendet wurden.Das bedeutet, dass du überprüfen kannst, dass die Teleportdaten von einem zugelassenen Ort stammen.

Da diese Daten vom Client übermittelt werden, kann sie möglicherweise immer noch von einem Exploiter missbraucht werden.Empfindliche Daten wie Spielerwährung sollten über eine sichere Lösung wie Speicherstores übermittelt werden.

Rückgaben

local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")

local analyticsStore = DataStoreService:GetDataStore("Analytics")

local ALLOWED_SOURCES = {
	"twitter",
	"youtube",
	"discord",
}

local function onPlayerAdded(player)
	local source = player:GetJoinData().LaunchData
	-- check if the provided source is valid
	if source and table.find(ALLOWED_SOURCES, source) then
		-- update the data store to track the source popularity
		local success, result = pcall(analyticsStore.IncrementAsync, analyticsStore, source)

		if success then
			print(player.Name, "joined from", source, "- total:", result)
		else
			warn("Failed to record join source: " .. result)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local DIRECT_JOIN_URL = "https://www.roblox.com/games/start?placeId=%d&launchData=%s"

local textBox = script.Parent

local function generateReferralURL(player)
	return DIRECT_JOIN_URL:format(game.PlaceId, player.UserId)
end

local function highlightAll()
	if -- avoid recursive property updates
		textBox:IsFocused() and not (textBox.SelectionStart == 1 and textBox.CursorPosition == #textBox.Text + 1)
	then
		textBox.SelectionStart = 1
		textBox.CursorPosition = #textBox.Text + 1
	end
end

textBox.Focused:Connect(highlightAll)
textBox:GetPropertyChangedSignal("SelectionStart"):Connect(highlightAll)
textBox:GetPropertyChangedSignal("CursorPosition"):Connect(highlightAll)

textBox.TextEditable = false
textBox.ClearTextOnFocus = false

textBox.Text = generateReferralURL(player)

local HttpService = game:GetService("HttpService")

local DATA_CHARACTER_LIMIT = 200

local function encodeTableAsLaunchData(data)
	-- convert the table to a string
	local jsonEncodedData = HttpService:JSONEncode(data)

	if #jsonEncodedData <= DATA_CHARACTER_LIMIT then
		-- escape potentially invalid characters, such as spaces
		local urlEncodedData = HttpService:UrlEncode(jsonEncodedData)
		return true, urlEncodedData
	else
		-- report character limit error
		return false, ("Encoded table exceeds %d character limit"):format(DATA_CHARACTER_LIMIT)
	end
end

local sampleData = {
	joinMessage = "Hello!",
	urlCreationDate = os.time(),
	magicNumbers = {
		534,
		1337,
		746733573,
	},
}

local success, encodedData = encodeTableAsLaunchData(sampleData)

if success then
	print(encodedData)
else
	warn("failed to encode launch data: " .. encodedData)
end

local HttpService = game:GetService("HttpService")
local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local launchData = player:GetJoinData().LaunchData
	if launchData then
		-- attempt to decode the data
		local success, result = pcall(HttpService.JSONDecode, HttpService, launchData)
		if success then
			print(player.Name, "joined with data:", result)
		else
			-- this is probably due to the user messing with the URL
			warn("Failed to parse launch data:" .. result)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

local Players = game:GetService("Players")

local approvedPlaceIds = { 1 } -- insert approved PlaceIds here

local function isPlaceIdApproved(placeId)
	for _, id in pairs(approvedPlaceIds) do
		if id == placeId then
			return true
		end
	end
	return false
end

local function onPlayerAdded(player)
	local joinData = player:GetJoinData()

	-- verify this data was sent by an approved place
	if isPlaceIdApproved(joinData.SourcePlaceId) then
		local teleportData = joinData.TeleportData
		if teleportData then
			local currentLevel = teleportData.currentLevel
			print(player.Name .. " is on level " .. currentLevel)
		end
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

Die Funktion GetMouse Player gibt die verwendet wird von dem Client zurück Mouse.Die Mausinstanz des Spielers kann verwendet werden, um die Maussteuerung des Benutzers zu verfolgen, einschließlich linker und rechter Mausklicks und Bewegung und Standort.

Der UserInputService bietet zusätzliche Funktionen und Ereignisse zur Verfolgung der Eingabe des Benutzers - insbesondere für Geräte, die keine Maus verwenden.

Hinweis:

• Dieser Gegenstand muss in einem LocalScript verwendet werden, um online wie erwartet zu funktionieren.
• Nach einem Update im Juli 2014 kann das Symbol der Maus jetzt mit dieser Methode festgelegt werden.

Rückgaben

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local mouse = player:GetMouse()

local function onButton1Down()
	print("Button 1 is down")
end

mouse.Button1Down:Connect(onButton1Down)

GetNetworkPing gibt die isolierte Netzwerkverzögerung der Player in Sekunden zurück.""Ping" ist eine Messung der Zeit, die für den Versand von Daten vom Client zum Server und dann wieder zurück benötigt wird.Es beinhaltet keine Datenserialisierung oder Verarbeitung.

Für die clientseitige LocalScripts kann diese Funktion nur auf der Players.LocalPlayer aufgerufen werden.Diese Funktion ist nützlich bei der Identifizierung und Fehlersuche von Problemen, die in hohen Netzwerk-Verzögerungszenarien auftreten.Es ist auch nützlich für die Maskierung der Verzögerung, wie das Anpassen der Geschwindigkeit der Wurfanimationen für Projektile.

Rückgaben

Die Funktion HasAppearanceLoaded Player gibt zurück, ob das Aussehen des Spielers Player.Character geladen wurde oder nicht.

Das Aussehen eines Spielers umfasst Elemente wie das Aussehen des Spielers Shirt, Pants und Accessories.

Dies ist nützlich, wenn es festgestellt werden soll, ob das Aussehen eines Spielers geladen wurde, nachdem er das Spiel zum ersten Mal betreten hat, was mit dem Ereignis Players.PlayerAdded verfolgt werden kann.

Rückgaben

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	local loaded = player:HasAppearanceLoaded()
	print(loaded)

	while not loaded do
		loaded = player:HasAppearanceLoaded()
		print(loaded)
		task.wait()
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)

Gibt einen booleschen Wert zurück, der den Überprüfungsstatus des Spielers anzeigt.Wenn wahr, wird der Spieler verifiziert.Die Verifizierung beinhaltet, ist aber nicht beschränkt auf, eine Nicht-VOIP-Telefonnummer oder die Überprüfung der Regierungs-ID.

Wenn Sie IsVerified implementieren, üben Sie Vorsicht, um sicherzustellen, dass die Implementierung nicht versehentlich alle nicht verifizierten Benutzer blockiert.

Beachten Sie, dass die Methode nur auf dem Backend-Server aufgerufen werden kann.Wenn es auf clientseitige Ergebnisse ausgeführt wird, führt dies zu einem Fehler.Darüber hinaus wird diese Methode immer false in Studio zurückgeben.

Rückgaben

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print(player:IsVerified())
end

for _, player in pairs(Players:GetPlayers()) do
	onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)

Die Methode Kick() ermöglicht es einer Erfahrung, einen Client elegant zu trennen und optional eine Nachricht an den getrennten Benutzer zu senden.Dies ist nützlich für die Moderation von missbräuchlichen Benutzern.Du solltest nur bestimmten Benutzern erlauben, diese Methode bei anderen Benutzern auszulösen, denen du vertraust.

Das Aufrufen dieser Methode auf einem Player ohne Argumente trennt den Benutzer vom Server und bietet eine Standardbenachrichtigungsnachricht.Das Aufrufen dieser Methode auf einer Player zusammen mit einer Zeichenkette als erstes Argument ersetzt die Standardnachricht durch die angegebene Zeichenkette.

Wenn diese Methode von einem LocalScript verwendet wird, kann nur der Client des lokalen Benutzers gekickt werden.

Parameter

Rückgaben

Die Funktion Bewegen Player lässt den Charakter des Spielers in die angegebene Richtung gehen, bis er vom Spieler gestoppt oder unterbrochen wird (mit Hilfe seiner Steuerelemente).

Dies ist nützlich, wenn du NPC programmierst, der sich auf einer Karte bewegt - aber nicht von der Eingabe eines echten Spielers gesteuert wird.

Beachten Sie, dass das zweite Argument der Funktion anzeigt, ob die bereitgestellte Vector3 den Spieler in Bezug auf die Weltkoordinaten bewegt (falsch) oder den Spieler in Camera (wahr).

Parameter

Rückgaben