Player

L'AccountAge est une propriété Player qui décrit depuis combien de jours le compte d'un joueur a été enregistré.Il est défini à l'aide de la fonction Player:SetAccountAge(), qui ne peut pas être accessible par les scripts.

Cette propriété est utile pour afficher conditionnellement le contenu des nouveaux joueurs Roblox tels que les tutoriels.

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- one week
local MIN_AGE_VETERAN = 365 -- one year

-- This function marks a part with text using a 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) -- Fill parent
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Add to part
	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)
	-- Listen for this player spawning
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

La propriété AutoJumpEnabled détermine si le Player.Character d'un Player utilisant un appareil mobile sautera automatiquement lorsqu'il heurte un obstacle.Cela peut rendre les niveaux plus navigables sur un appareil mobile.

Lorsque le joueur rejoint le jeu, la valeur StarterPlayer.AutoJumpEnabled détermine l'état initial de cette propriété.Ensuite, cette propriété détermine la valeur de la propriété Humanoid.AutoJumpEnabled de la Player.Character à régénération, apparition.En d'autres termes, il est possible de définir le comportement de saut automatique sur une base par caractère, par joueur et par jeu en utilisant ces trois propriétés.

local Players = game:GetService("Players")

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

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

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

button.Activated:Connect(onActivated)
update()

La propriété CameraMaxZoomDistance Player définit la distance maximale en studs que la caméra peut être du personnage avec les caméras par défaut.

En d'autres termes, il contrôle la distance maximale à laquelle la caméra du joueur peut se dézoomer.

La valeur par défaut de cette propriété est définie par StarterPlayer.CameraMaxZoomDistance .Si cette valeur est définie sur une valeur inférieure à Player.CameraMinZoomDistance, elle sera augmentée à CameraMinZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La propriété CameraMinZoonDistance Player définit la distance minimale en studs que la caméra peut être du personnage avec les caméras par défaut.

En d'autres termes, il contrôle la distance minimale à laquelle la caméra du joueur peut se zoomer.

La valeur par défaut de cette propriété est définie par StarterPlayer.CameraMinZoomDistance .Si cette valeur est définie sur une valeur supérieure à Player.CameraMaxZoomDistance, elle sera réduite à CameraMaxZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La propriété Mode de caméra défini le mode de caméra du joueur, par défaut en troisième personne.

3e personne

Dans le mode par défaut de la troisième personne ( Enum.CameraMode.Classic ), le personnage peut être vu dans la caméra. Pendant que dans ce mode, le comportement par défaut est :

• Les joueurs peuvent cliquer avec le bouton droit et faire glisser (souris), tapper et faire glisser (mobile), utiliser le joystick secondaire (manette de jeu) ou appuyer sur les flèches gauche/droite (clavier) pour faire pivoter la caméra autour de leur personnage.
• Lorsqu'un joueur déplace son personnage, il se trouve face dans la direction du mouvement correspondante.
• Les joueurs peuvent zoomer et dézoomer librement, même jusqu'à la première personne en plein zoom.

Première personne

En mode première personne ( Enum.CameraMode.LockFirstPerson ), la caméra du joueur est zoomée jusqu'au bout.À moins qu'il n'y ait une interface visuelle présente avec la propriété GuiButton.Modal définie sur true , en déplaçant la souris, en faisant glisser sur mobile ou en utilisant le joystick secondaire sur une manette de jeu, la caméra tournera autour du personnage.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMode = Enum.CameraMode.LockFirstPerson

La propriété CanLoadCharacterAppearance Player détermine si l'apparence du personnage sera chargée lorsque le joueur apparaît.La valeur par défaut de cette propriété est définie par StarterPlayer.LoadPlayerAppearance .

Si vrai , le personnage chargera l'apparence du joueur correspondant au joueur Player.CharacterAppearanceId .

Si faux , le joueur apparaîtra avec une apparence par défaut - un modèle de personnage gris sans chapeaux, chemises, pantalons, etc.

Tenter de définir la propriété après que le personnage ait été généré ne changera pas le personnage, vous devez appeler Player:LoadCharacter() pour charger la nouvelle apparence.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CanLoadCharacterAppearance = false

La propriété Caractère contient une référence à un Model contenant un Humanoid , des parties du corps, des scripts et d'autres objets nécessaires pour simuler l'avatar du joueur dans l'expérience.Le modèle est parenté au Workspace mais il peut être déplacé.Il est automatiquement chargé lorsque Players.CharacterAutoLoads est true et qu'il peut être chargé manuellement autrement en utilisant Player:LoadCharacter() .

Initialement, cette propriété est nil et elle est définie lorsque le personnage du joueur apparaît pour la première fois.Utilisez l'événement Player.CharacterAdded pour détecter quand le personnage d'un joueur se charge correctement, et l'événement Player.CharacterRemoving pour détecter quand le personnage est sur le point de disparaître.Évitez d'utiliser Object:GetPropertyChangedSignal() sur cette propriété.

Notez que LocalScripts lesquelles sont clonées à partir de StarterGui ou StarterPack dans le modèle d'un joueur PlayerGui ou Backpack sont souvent exécutées avant que le vieux modèle de caractère ne soit remplacé, donc Player.Character peut se référer au vieux modèle dont la propriété Parent est nil .Il est donc conseillé, dans un LocalScript sous StarterGui ou StarterPack , de s'assurer que le parent de Caractère n'est pas nil avant de l'utiliser, par exemple :

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

Cette propriété détermine l'ID utilisateur du compte dont l'apparence du personnage est utilisée pour un joueur de character.Par défaut, cette propriété est la Player.UserId , qui utilise l'avatar du joueur tel qu'il l'a créé sur le site Web Roblox.

Changer cette propriété en l'ID utilisateur d'un autre compte provoquera la génération du joueur avec l'apparence de ce compte (chapeaux, chemises, pantalons, etc).

Les jeux peuvent également basculer sur le fait que la apparence du personnage d'un joueur soit chargée dans le jeu ou non en modifiant la propriété StarterPlayer.LoadCharacterAppearance.

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 -- Number failed to parse, maybe they typed a username instead
			pcall(function() -- This call can fail sometimes!
				id = Players:GetUserIdFromNameAsync(input) -- Fetch ID from name
			end)
		end
		if id then
			-- Set character appearance then respawn
			player.CharacterAppearanceId = id
			player:LoadCharacter()
		else
			-- We couldn't get an ID from their input
		end
	end
end

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

Players.PlayerAdded:Connect(onPlayerAdded)

Définit la manière dont les scripts de caméra par défaut gèrent les objets entre la caméra et le sujet de la caméra.Défini par StarterPlayer.DevCameraOcclusionMode et ne peut pas être modifié pour les joueurs individuels.

La valeur par défaut est Zoom (0). Voir Enum.DevCameraOcclusionMode pour une liste des modes disponibles.

La propriété DevComputerCameraMode détermine la manière dont un joueur déplace sa caméra lorsqu'il utilise un appareil avec une souris et un clavier.Voir Enum.DevComputerCameraMovementMode pour une description de chaque mode de contrôle de caméra disponible.Cette propriété ne peut pas être définie en utilisant un LocalScript (elle doit être définie sur le serveur en utilisant un Script ).

La valeur par défaut de cette propriété est déterminée par StarterPlayer.DevComputerCameraMovementMode.

Le mot « Ordinateur » dans ce nom de propriété fait référence à des appareils non TouchEnabled , non GamepadEnabled .

Lorsqu'il est défini à choix de l'utilisateur , un joueur peut choisir parmi n'importe quel mode de contrôle (sauf scriptable ) dans les paramètres du jeu Roblox.En général, il est une bonne idée de permettre aux joueurs de choisir leur mode de contrôle pour maximiser l'accessibilité.

Il est possible de créer un schéma de contrôle personnalisé en définissant cette propriété sur Scriptable .

Cette propriété n'affecte pas les joueurs utilisant un appareil tactile activé. Voir 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

La propriété DevComputerMovementMode détermine la manière dont un joueur déplace son personnage lorsqu'il utilise un appareil avec une souris et un clavier.Voir Enum.DevComputerMovementMode pour une description de chaque mode de contrôle de mouvement disponible.Cette propriété ne peut pas être définie en utilisant un LocalScript (elle doit être définie sur le serveur en utilisant un Script ).

La valeur par défaut de cette propriété est déterminée par StarterPlayer.DevComputerMovementMode.

Le mot « Ordinateur » dans ce nom de propriété fait référence aux appareils non TouchEnabled de.

Lorsqu'il est défini à choix de l'utilisateur , un joueur peut choisir parmi n'importe quel mode de contrôle (sauf scriptable ) dans les paramètres du jeu Roblox.En général, il est une bonne idée de permettre aux joueurs de choisir leur mode de contrôle pour maximiser l'accessibilité.

Il est possible de créer un schéma de contrôle personnalisé en définissant cette propriété sur Scriptable .

Cette propriété n'affecte pas les joueurs utilisant un appareil tactile activé. Voir 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)

Cette propriété détermine si un joueur peut basculer le verrouillage Mouse en appuyant sur Maj .Un joueur peut désactiver le bouton de verrouillage de la souris dans les paramètres de jeu de Roblox.Par défaut, cette propriété est définie à la valeur de StarterPlayer.EnableMouseLockOption .Cela peut être défini côté serveur pendant l'exécution en utilisant un Script .Il ne peut pas être défini côté client.

Lorsque la verrouillage de la souris est activé, le curseur du joueur est verrouillé au centre de l'écran.Déplacer la souris orbitera autour de la caméra autour du joueur character , et le personnage sera face à la même direction que le camera .Il déplace également la vue de la caméra juste au-dessus de l'épaule droite du personnage du joueur.

Notez que les API liées au verrouillage de la touche de changement de page sont en train d'être marquer comme obsolète, il est donc recommandé d'utiliser UserInputService.MouseBehavior à la place pour verrouiller la souris.

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)

La propriété DevTouchCameraMode détermine la manière dont un joueur déplace sa caméra lorsqu'il utilise un appareil TouchEnabled.Voir Enum.DevTouchCameraMovementMode pour une description de chaque mode de contrôle de caméra disponible.Cette propriété ne peut pas être définie en utilisant un LocalScript (elle doit être définie sur le serveur en utilisant un Script ).

La valeur par défaut de cette propriété est déterminée par StarterPlayer.DevTouchCameraMovementMode.

Lorsqu'il est défini à choix de l'utilisateur , un joueur peut choisir parmi n'importe quel mode de contrôle (sauf scriptable ) dans les paramètres du jeu Roblox.En général, il est une bonne idée de permettre aux joueurs de choisir leur mode de contrôle pour maximiser l'accessibilité.

Il est possible de créer un schéma de contrôle personnalisé en définissant cette propriété sur Scriptable .

Cette propriété n'affecte pas les joueurs qui n'utilisent pas un appareil tactile activé. Voir 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

La propriété DevTouchMovementMode détermine la manière dont un joueur déplace son personnage lorsqu'il utilise un appareil TouchEnabled.Voir Enum.DevTouchMovementMode pour une description de chaque mode de contrôle de mouvement disponible.Cette propriété ne peut pas être définie en utilisant un LocalScript (elle doit être définie sur le serveur en utilisant un Script ).

La valeur par défaut de cette propriété est déterminée par StarterPlayer.DevTouchMovementMode.

Lorsqu'il est défini à choix de l'utilisateur , un joueur peut choisir parmi n'importe quel mode de contrôle (sauf scriptable ) dans les paramètres du jeu Roblox.En général, il est une bonne idée de permettre aux joueurs de choisir leur mode de contrôle pour maximiser l'accessibilité.

Il est possible de créer un schéma de contrôle personnalisé en définissant cette propriété sur Scriptable .

Cette propriété n'affecte pas les joueurs qui n'utilisent pas un appareil tactile activé. Voir 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)

Le DisplayName est une propriété Player qui contient le nom d'affichage de l'utilisateur authentifié associé à l'objet Player.Contrairement aux noms d'utilisateur, les noms d'affichage sont des noms non uniques que le joueur affiche aux autres.Si l'utilisateur Roblox n'en a pas choisi, la propriété lira la même chose que la propriété Name.

Remarque :

• Puisque les noms d'affichage ne sont pas uniques, il est possible que deux joueurs dans une seule instance aient des noms identiques.Si vous avez besoin d'un identifiant globalement unique pour un joueur, utilisez Player.UserId (qui est statique) ou Player.Name (qui est le nom d'utilisateur actuel) à la place.
• Les personnages générés avec Player.LoadCharacter ou par le moteur Roblox recevront leur propriété Humanoid.DisplayName à la propriété Player.DisplayName.
• Les noms d'affichage peuvent avoir des caractères unicode dans la chaîne. Voir UTF-8 pour plus d'informations sur la façon de travailler avec des chaînes ayant des caractères unicode.

L'identifiant de suivi est une propriété Player qui contient le Player.UserId de l'utilisateur que le joueur a suivi dans le jeu.Si le joueur n'a suivi personne dans le jeu, cette propriété sera à 0.Cette propriété est utile pour alerter les joueurs qui ont été suivis par un autre joueur dans le jeu.

Vous pouvez obtenir le nom du joueur suivi en utilisant cet ID d'utilisateur et la fonction Players:GetNameFromUserIdAsync().

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)

La propriété GameplayPaused indique si le joueur est actuellement en état de pause dans un endroit avec StreamingEnabled activé.Il est défini sur le client mais répliqué au serveur.Pour déterminer le statut de pause, vous pouvez utiliser cette propriété.

Voir aussi :

• Workspace.StreamingEnabled qui contrôle si le streaming de contenu est activé
• Workspace.StreamingIntegrityMode et Enum.StreamingIntegrityMode pour plus de détails sur le moment où le jeu est interrompu.

La propriété HasVerifiedBadge Player indique si le joueur a une Vérification badge/ Badge vérifié.

La propriété HealthDisplayDistance définit la distance en points à laquelle ce joueur verra d'autres barres de santé.Si la valeur est réglée sur 0, les barres de santé ne seront pas affichées.Cette propriété est définie par défaut à StarterPlayer.HealthDisplayDistance .

Si la barre de santé d'un humanoïde est visible, vous pouvez définir le type d'affichage en utilisant Humanoid.DisplayDistanceType .

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

La propriété LocaleId Player montre l'ID local que le joueur local a défini pour son compte Roblox.Il contient une chaîne avec le code à deux lettres (par exemple, "en-us") pour la localité.

Cela peut être utilisé pour déterminer la démographie géographique de la base de joueurs de votre jeu, et est également le local qui sera utilisé pour la localisation automatique du contenu en expérience (voir GuiBase2d.AutoLocalize ).Cette propriété permet d'accéder à la localité du joueur depuis le serveur.

Voir aussi LocalizationService.RobloxLocaleId , l'ID local utilisé pour localiser le contenu interne.Ce sera une valeur différente lorsque Roblox ne prend pas encore en charge localement le set local du joueur local.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

print(player.LocaleId)

Cette propriété ne peut être lue que pour déterminer l'appartenance (elle ne peut pas être définie sur un autre taperd'appartenance).Il contient un Enum.MembershipType enum du taperd'adhésion du compte.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

if player.MembershipType == Enum.MembershipType.Premium then
	-- Take some action specifically for Premium members
end

La propriété NameDisplayDistance StarterPlayer défini la distance en studs à laquelle ce joueur verra d'autres noms Humanoid.Si la propriété est définie à 0, les noms sont cachés.Cette propriété est définie par défaut à StarterPlayer.NameDisplayDistance .

Si la barre de santé d'un humanoïde est visible, vous pouvez définir le type d'affichage en utilisant Humanoid.DisplayDistanceType .

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.HealthDisplayDistance = 0
player.NameDisplayDistance = 0

La propriété Neutre détermine si le joueur est dans une équipe spécifique.

• Lorsque vrai, le joueur n'est pas dans une équipe spécifique.Cela signifie également que la propriété Player.Team sera nil et que la propriété Player.TeamColor sera blanche.
• Lorsque faux, le joueur est dans une équipe spécifique.La propriété Player.Team correspondra à la Team sur laquelle se trouve le joueur, tout comme la Player.TeamColor .

local Players = game:GetService("Players")

local player = Players.LocalPlayer

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

La propriété ReplicationFocus Player définit la partie à se concentrer sur la réplication autour d'un joueur.Les différents systèmes Roblox qui communiquent sur le réseau (tels que la physique, le streaming, etc.) se reproduisent à différents rythmes en fonction de la proximité des objets par rapport au focus de réplication.

Lorsque cette propriété est , elle revient à son comportement par défaut qui consiste à traiter le caractère du joueur local comme focus de réplication.

Cette propriété ne doit être définie sur le serveur qu'avec un Script , pas avec un LocalScript .Notez que cette propriété ne change pas ou n'actualise pas la propriété réseau des parties.

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

Si configurer, le joueur réapparaîtra au donné SpawnLocation.Cette propriété ne peut être définie que via Luau et doit contenir une référence à un valid SpawnLocation , qui doit répondre aux critères suivants :

• Descendant de Workspace
• SpawnLocation.TeamColor est défini sur le Player.TeamColor ou SpawnLocation.Neutral est défini sur vrai

Si RespawnLocation n'est pas défini sur une valeur valide SpawnLocation, la logique d'apparition par défaut s'appliquera.Pour plus d'informations à ce sujet, voir la page pour SpawnLocation .

Alternatives à RespawnLocation

• Un Player apparaîtra de SpawnLocations appartenant à leur équipe. Dans certains cas, il peut être plus simple de changer le Player.Team du joueur à la place.
• Implémentez votre propre logique de génération personnalisée en utilisant PVInstance:PivotTo() pour déplacer manuellement le Player.Character.

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

La propriété Équipe est une référence à un objet Team dans le service Teams.Il détermine l'équipe à laquelle le joueur appartient ; si le Player n'est pas dans une équipe ou a un Player.TeamColor non valide, cette propriété est nil .Lorsque cette propriété est configurer, le joueur a rejoint le Team et l'événement Team.PlayerAdded se déclenche sur l'équipe associée.De même, Team.PlayerRemoved feux lorsque la propriété est désactivée à partir d'un certain Team.

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)

La propriété TeamColor détermine à quel équipe un joueur est associé selon la Team.TeamColor de cette équipe.Changer cette propriété changera Player.Team selon l'équipe qui a le même BrickColor pour son Team.TeamColor .Si aucun objet d'équipe n'a la couleur d'équipe associée, le joueur ne sera pas associé à une équipe.

Il est souvent une meilleure idée de définir Player.Team à la propriété respective Team au lieu d'utiliser cette propriété.Définir cette propriété entraîne souvent la répétition de la même valeur de couleur de brique pour une certaine équipe à travers de nombreux scripts ; c'est quelque chose que vous voulez éviter en adhérant au principe « Ne vous répétez pas vous-même » (DRY).

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)

L'ID utilisateur est une propriété qui contient un entier de lecture seule qui identifie de manière unique et cohérente chaque compte utilisateur sur Roblox.Contrairement au Instance.Name d'un joueur, qui peut changer selon le nom d'utilisateur actuel de l'utilisateur, cette valeur ne changera jamais pour le même compte.

Cette propriété est essentielle lors de l'enregistrement/du chargement des données du joueur en utilisant GlobalDataStores .Utilisez l'ID utilisateur d'un joueur comme clé du magasin de données afin que chaque joueur ait une clé unique.

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)

Paramètres

Retours

La fonction ClearCharacterAppearance supprime tout Accessory , Shirt, Pants, CharacterMesh et BodyColors du joueur donné Player.Character.En outre, il supprime également la chemise Decal sur le torse du joueur.La partie du corps et le visage du personnage resteront inchangés.Cette méthode ne fait rien si le joueur n'a pas de personnage.

Il ne supprime pas t-shirts , les mailles de tête ou les visages.

Retours

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

La fonction DistanceFromCharacter Player retourne la distance entre la tête du personnage et le point donné Vector3.Il renvoie 0 si le joueur n'a pas de Player.Character.

Cela est utile pour déterminer la distance entre un joueur et un autre objet ou lieu dans le jeu.

Si vous souhaitez déterminer la distance entre deux instances ou positions non joueurs, vous pouvez utiliser ce qui suivre:

local distance = (position1 - position2).Magnitude

Paramètres

Retours

local Players = game:GetService("Players")

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

Renvoie un dictionnaire contenant des informations sur la façon dont le joueur rejoint l'expérience. Le dictionnaire contient l'un des champs suivants :

<th>Type de valeur</th>

    <th>Avertissement</th>
  </tr>
</thead>

<tbody>
  <tr>
    <th>ID de jeu source</th>

    <td>numéro</td>

    <td>Le <code>Class.DataModel.GameId</code> de l'expérience du <code>Joueur</code> téléporté d'où.Se présente seulement si le joueur se téléporte dans l'expérience actuelle et si un serveur appelle la fonction de téléportation.</td>
  </tr>

  <tr>
    <th>Id de lieu de source</th>

    <td>numéro</td>

    <td>Le <code>Class.DataModel.PlaceId</code> de l'endroit où le <code>joueur</code> a été téléporté.Se présente seulement si le joueur se téléporte à l'endroit actuel et qu'un serveur appelle la fonction de téléportation.</td>
  </tr>

  <tr>
    <th>Référencé par PlayerId</th>

    <td>numéro</td>

    <td>La classe <code>Class.Player.UserId</code> du joueur qui a invité le joueur actuel à l'expérience.Utilisez ces données pour identifier le référent et déclencher la logique de récompense.</td>
  </tr>

  <tr>
    <th>Membres</th>

    <td>matrice</td>

    <td>Un tableau contenant les numéros <code>Class.Player.UserId</code> des utilisateurs téléportés aux côtés du <code>Joueur</code>.Se présente seulement si le joueur se téléporte dans le cadre d'un groupe.</td>
  </tr>

  <tr>
    <th>Données de téléportation</th>

    <td>variété</td>

    <td>Renvoie les données de téléportation <code>spécifiées dans le téléport original</code>.Utile pour partager des informations entre les serveurs auquel le joueur se téléporte.Se présente seulement si <code>teleportData</code> a été spécifié et qu'un serveur appelle la fonction de téléportation.</td>
  </tr>

  <tr>
    <th>Données de lancement</th>

    <td>chaîne</td>

    <td>Une chaîne simple ou JSON codée qui contient les données de lancement spécifiées dans un <a href="/production/promotion/deeplinks">lien profond</a> URL ou <code>Class.ExperienceInviteOptions.LaunchData</code>.</td>
  </tr>

  <tr>
    <th>GameJoinContext</th><td>dictionnaire</td>

    <td>
      Un dictionnaire qui inclut des informations pertinentes en fonction du contexte de la participation du jeu. Il contient les clés suivantes :

      <ul>
        JoinSource : Enum.JoinSource Type d'objet : facultatif Enum.AvatarItemType ID de ressource : facultatif chaîne OutfitId : facultatif chaîne Type de ressource : facultatif Enum.ResourceType AssetType : facultatif chaîne
      </ul>
    </td>
  </tr>
</tbody>

Obtenir des données de jointure et des données de téléportation

Si un serveur initie la téléportation du joueur, le dictionnaire que cette méthode renvoie inclut les données de téléportation du joueur.La méthode Player:GetJoinData() ne peut être utilisée que pour récupérer des données de téléportation sur le serveur.Pour récupérer les données sur le client, utilisez TeleportService:GetLocalPlayerTeleportData() .

Contrairement à TeleportService:GetLocalPlayerTeleportData(), Player:GetJoinData() ne fournit que des données de téléportation qui répondent aux critères de sécurité suivants :

• Il est garanti d'avoir été envoyé par un serveur Roblox au cours des 48 dernières heures.
• Il est garanti d'avoir été envoyé avec ce Player .
• Les SourcePlaceId et SourceGameId sont garantis être l'endroit et l'univers d'où les données ont été envoyées.Cela signifie que vous pouvez vérifier que les données de téléportation proviennent d'un emplacementapprouvé.

Comme ces données sont transmises par le client, elles peuvent encore potentiellement être abusées par un exploiteur.Les données sensibles telles que la devise du joueur doivent être transmises via une solution sécurisée comme magasins de mémoire.

Retours

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)

La fonction GetMouse Player retourne le Mouse utilisé par le client.L'instance de la souris du joueur peut être utilisée pour suivre l'entrée de la souris de l'utilisateur, y compris les clics du bouton gauche et droit de la souris et le mouvement et l'emplacement.

Le service UserInputService fournit des fonctions et des événements supplémentaires pour suivre l'entrée de l'utilisateur - notamment pour les appareils qui n'utilisent pas de souris.

Remarque :

• Cet élément doit être utilisé dans un LocalScript pour fonctionner comme prévu en connecté.
• Après une mise à jour en juillet 2014, l'icône de la souris peut désormais être définie avec cette méthode.

Retours

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 renvoie la latence réseau isolée du Player en secondes.« Ping » est une mesure du temps pris pour envoyer les données du client au serveur, puis revenir en arrière.Il n'implique pas la désérialisation ou le traitement des données.

Pour le côté client LocalScripts, cette fonction ne peut être appelée que sur le Players.LocalPlayer.Cette fonction est utile pour identifier et résoudre les problèmes qui se produisent dans des scénarios de latence réseau élevée.Il est également utile pour masquer la latence, comme l'ajustement de la vitesse des animations de lancer pour les projectiles.

Retours

La fonction HasAppearanceLoaded Player renvoie si oui ou non l'apparence du joueur Player.Character a été chargée.

L'apparence d'un joueur comprend des éléments tels que le Shirt , le Pants et le Accessories du joueur.

Cela est utile pour déterminer si l'apparence d'un joueur s'est chargée après qu'il ait rejoint le jeu pour la première fois, ce qui peut être suivi à l'aide de l'événement Players.PlayerAdded.

Retours

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)

Renvoie une valeur booléenne indiquant le statut de vérification du joueur.Lorsque c'est vrai, le joueur est vérifié.La vérification inclut, mais ne se limite pas à, le numéro de téléphone non-VOIP ou la vérification de l'identifiant gouvernemental.

Lors de l'implémentation de IsVerified, faites preuve de prudence pour vous assurer que la mise en œuvre ne bloque pas accidentellement tous les utilisateurs non vérifiés.

Notez que la méthode ne peut être appelée que sur le serveur arrière-plan.L'appeler des résultats côté client entraîne une erreur.De plus, cette méthode retournera toujours false dans Studio.

Retours

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)

La méthode Kick() permet à une expérience de se déconnecter élégamment d'un client et d'envoyer un message à l'utilisateur déconnecté facultativement.Cela est utile pour modérer les utilisateurs abusifs.Vous ne devez autoriser que des utilisateurs spécifiques que vous avez confiance à déclencher cette méthode sur d'autres utilisateurs.

Appeler cette méthode sur un Player sans argument déconnecte l'utilisateur du serveur et fournit un message d'avertissement par défaut.Appeler cette méthode sur un Player avec une chaîne en tant que premier argument qui remplace le message par défaut par la chaîne fournie.

Lors de l'utilisation de cette méthode à partir d'un LocalScript, seul le client de l'utilisateur local peut être expulsé.

Paramètres

Retours

La fonction déplacer Player fait en sorte que le personnage du joueur marche dans la direction donnée jusqu'à ce qu'il soit arrêté ou interrompu par le joueur (en utilisant ses contrôles).

Cela est utile lorsque vous scriptez des PNJ Humanoids

Notez que l'argument secondaire de la fonction indique si le Vector3 fourni devrait déplacer le joueur par rapport aux coordonnées du monde ( faux ) ou le Camera du joueur ( vrai ).

Paramètres

Retours

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

-- Wait for the player's character and humanoid, which must exist before calling :Move()
local character = localPlayer.Character or localPlayer.CharacterAdded:Wait()
character:WaitForChild("Humanoid")

-- The player will move until they are 50 studs away from the camera's position at the time of running
localPlayer:Move(Vector3.new(0, 0, -50), true)

Paramètres

Retours

La fonction SetAccountAge défini le Player.AccountAge du joueur en jours.

Il est utilisé pour définir la propriété Player qui décrit depuis combien de jours le compte d'un joueur a été enregistré.

Cela ne défini pas l'âge du joueur sur le compte, mais l'âge du compte lui-même par rapport à celui de sa création initiale.

Paramètres

Retours

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player:SetAccountAge(100)

local Players = game:GetService("Players")

local MAX_AGE_NEW_PLAYER = 7 -- one week
local MIN_AGE_VETERAN = 365 -- one year

-- This function marks a part with text using a 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) -- Fill parent
	textLabel.Text = text
	textLabel.TextColor3 = Color3.new(1, 1, 1)
	textLabel.TextStrokeTransparency = 0
	textLabel.BackgroundTransparency = 1
	textLabel.Parent = bbgui
	-- Add to part
	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)
	-- Listen for this player spawning
	if player.Character then
		onPlayerSpawned(player, player.Character)
	end
	player.CharacterAdded:Connect(function()
		onPlayerSpawned(player, player.Character)
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)