Player

L'Âge du compte est une propriété Player qui décrit le temps qu'il y a écoulé avant que le compte d'un joueur soit enregistré dans les jours. 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 à l'aide d'un appareil mobile sautera automatiquement lorsqu'il touchera un obstacle. Cela peut rendre les niveaux plus navigables lorsqu'on est sur un appareil mobile.

Lorsque le joueur rejoint le jeu, la valeur StarterPlayer.AutoJumpEnabled détermine l'état initial de cette propriété. Puis, cette propriété détermine la valeur de la propriété Humanoid.AutoJumpEnabled de la propriété Player.Character au moment de la régénération, apparition. En d'autres

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 valeur CameraMaxZoomDistance Player détermine la distance maximum en studs que la caméra peut avoir du personnage avec les caméras par défaut.

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

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

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La CameraMinZoonDistance Player propriété définit la distance minimum 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 que la caméra du joueur peut zoomer.

La valeur par défaut de cette propriété est définie par StarterPlayer.CameraMinZoomDistance. Si cette valeur est définie à un niveau supérieur à Player.CameraMaxZoomDistance, elle est réduite à CameraMaxZoomDistance.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

player.CameraMaxZoomDistance = 50
player.CameraMinZoomDistance = 75

La propriété CameraMode définie le mode de caméra du joueur, par défaut à la troisième personne.

Troisième personne

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

• Les joueurs peuvent cliquer avec le bouton droit (souris), faire un clic avec le bouton de souris (souris), appuyer et faire glisser (touche mobile), utiliser le joystick secondaire (gamepad), ou appuyer sur les flèches de gauche à droite (clavier) pour faire pivoter la caméra autour de leur personnage.
• Lorsqu'un joueur déplace son personnage, il fait face dans la direction de déplacement correspondante.
• Les joueurs peuvent zoomer vers l'intérieur et vers l'extérieur librement, même à la première personne en full zoom.

Première personne

En mode première personne ( Enum.CameraMode.LockFirstPerson ) la caméra du joueur est zoomée tout le long de l'axe. À moins qu'il n'y ait une GUI visible avec la propriété GuiButton.Modal définie sur true , en déplaçant la souris, en faisant un clic droit sur mobile ou en utilisant le joystick secondaire sur un gamepad, la caméra tourner

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îtra. 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 à la classe du 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 la réapparition du personnage 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é Personnage contient une référence à un Model contenant un Humanoid , des parties du corps, des scripts et d'autres objets requis pour simuler l'av

Initialement, cette propriété est nil et elle est définie lorsque le personnage d'un joueur apparaît pour la première fois. Utilisez l'événement Player.CharacterAdded pour détecter lorsque un personnage apparaît correctement, et l'événement Player.CharacterRemoving pour détecter quand le personnage est sur le point de dispara

Notez que LocalScripts qui sont clonés à partir de StarterGui ou Class.StarterPack

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 de l'utilisateur du compte dont la réapparition du personnage est utilisée pour le jeu d'un joueur. Par défaut, cette propriété est la Player.Character, qui utilise l'avatar du joueur tel qu'il l'a créé sur le site Web de Roblox.

Changer cette propriété en ID d'utilisateur d'un autre compte fera apparaître le joueur avec l'apparence de cet compte (chapeaux, chemises, pantalons, etc).

Les jeux peuvent également activer ou non l'apparence du personnage d'un joueur en changeant 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 comment les scripts de caméra par défaut gèrent les objets entre la caméra et le sujet de 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 de 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 (il doit être défini 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 « Computer » dans ce nom de propriété fait référence aux appareils non- TouchEnabled , non- GamepadEnabled .

Lorsqu'il est réglé sur Choix de l'utilisateur , un joueur peut choisir entre n'importe quel mode de contrôle (y compris Scriptable ) dans les paramètres du jeu Roblox. En général, il est une bonne idée d'autoriser les joueurs à 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 utilisent un appareil tactile. Voir Player.DevTouchCameraMode à la place.

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 déplacement disponible. Cette propriété ne peut pas être définie en utilisant un LocalScript (il doit être défini 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 « Computer » dans ce nom de propriété fait référence aux appareils non TouchEnabled.

Lorsqu'il est réglé sur Choix de l'utilisateur , un joueur peut choisir entre n'importe quel mode de contrôle (y compris Scriptable ) dans les paramètres du jeu Roblox. En général, il est une bonne idée d'autoriser les joueurs à 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 utilisent un appareil tactile. Voir Player.DevTouchMovementMode à la place.

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 activer le verrouillage Mouse en appuyant sur Maj . Un joueur peut désactiver le verrouillage de la souris dans les paramètres de jeu de Roblox. Par défaut, cette propriété est réglée sur la valeur de StarterPlayer.EnableMouseLockOption. Cela peut être

Lorsque la verrouillage de la souris est activé, le curseur du joueur est verrouillé au centre de l'écran. En déplaçant la souris, vous orbitez la caméra autour du joueur character , et le personnage face à la même direction que la caméra camera . Il déplace également la vue de la caméra juste au-dessus de l'épaule du personnage du joueur.

Notez que les API de verrouillage de changement de vitesse sont en cours de 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 (

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

Lorsqu'il est réglé sur Choix de l'utilisateur , un joueur peut choisir entre n'importe quel mode de contrôle (y compris Scriptable ) dans les paramètres du jeu Roblox. En général, il est une bonne idée d'autoriser les joueurs à 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 ne utilisent pas un appareil de touche. Voir Player.DevComputerCameraMovementMode à la place.

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 déplacement disponible. Cette propriété ne peut pas être définie en utilisant un LocalScript (il doit être

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

Lorsqu'il est réglé sur Choix de l'utilisateur , un joueur peut choisir entre n'importe quel mode de contrôle (y compris Scriptable ) dans les paramètres du jeu Roblox. En général, il est une bonne idée d'autoriser les joueurs à 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 ne utilisent pas un appareil de touche. Voir Player.DevComputerMovementMode à la place.

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)

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

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 unique au niveau mondial pour un joueur, utilisez Player.UserId (qui est statique) ou Player.Name (qui est le nom actuel) au lieu de cela.
• Les personnages générés avec Player.LoadCharacter ou par le moteur Roblox auront leur propriété Humanoid.DisplayName attribuée à la propriété Player.DisplayName.
• Les noms peuvent avoir des caractères inexistants dans la chaîne. Voir UTF-8 pour plus d'informations sur le fonctionnement des chaînes avec des caractères inexistants.

Le FollowUserId 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 pas suivi personne dans le jeu, cette propriété sera 0. Cette propriété est utile pour avertir les joueurs qui ont été suivis par un autre joueur dans le jeu.

Vous pouvez obtenir le nom du joueur suivant en utilisant ce Players:GetNameFromUserIdAsync() fonction.

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 dans un état de pause dans un lieu avec StreamingEnabled activé. Elle est configurée sur le client, mais répliquée sur le serveur. Pour déterminer le statut de pause, vous pouvez utiliser cette propriété.

Voir aussi :

• Workspace.StreamingEnabled qui contrôle si le flux de contenu est activé
• Workspace.StreamingIntegrityMode et Enum.StreamingIntegrityMode pour plus de détails sur la façon dont le jeu est suspendu.

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

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

Si la barre de santé d'un humanoid 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'identifiant du lieu que le joueur local a défini pour son compte Roblox. Il contient une chaîne contenant le code de deux lettres (par exemple, «en-us») pour le lieu.

Ceci peut être utilisé pour déterminer la démographie géographique de la base de joueurs de votre jeu, et est également la langue utilisée pour la localisation automatique (voir GuiBase2d.AutoLocalize) du contenu dans l'expérience. Cette propriété permet d'accéder à la langue du joueur du serveur.

Voir aussi LocalizationService.RobloxLocaleId, l'identifiant de la langue utilisée pour localiser le contenu interne. Ce sera une valeur différente lorsque Roblox ne prendra pas encore en charge localement le langage de l'joueur.

local Players = game:GetService("Players")

local player = Players.LocalPlayer

print(player.LocaleId)

Cette propriété ne peut être lue que pour déterminer l'adhésion (elle ne peut pas être définie pour un autre taperd'adhésion). Elle contient un Enum.MembershipType ensemble de 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é Nom de l'écran StarterPlayer détermine la distance en studs à laquelle ce joueur verra d'autres noms Humanoid. Si la propriété est réglée sur 0, les noms sont cachés. Cette propriété est réglée sur StarterPlayer.NameDisplayDistance par défaut.

Si la barre de santé d'un humanoid 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 nul et que la couleur Player.TeamColor sera blanche.
• Lorsque faux , le joueur est dans une équipe spécifique. La propriété Player.Team correspondra à la Team que le joueur est sur, ainsi que la couleur de l'équipe 1> Class.Player.TeamColor1>.

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 pour se concentrer sur la réplication autour d'un joueur. Différents systèmes Roblox qui communiquent via le réseau (tels que la physique, le streaming, etc) répliquent à différents taux en fonction de la proximité des objets du point de vue de la réplication.

Lorsque cette propriété est nulle, elle revient à son comportement par défaut qui est de traiter le personnage du joueur local comme le PrimaryPart de la réplication comme le point focal de réplication.

Cette propriété ne doit être définie que sur le serveur avec un Script, pas un LocalScript. Notez que cette propriété ne modifie pas ou ne met à jour la propriété réseau de 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 à la valeur donnée SpawnLocation. Cette propriété ne peut être définie que via Lua et doit contenir une référence à un SpawnLocation valide, qui doit répondre aux critères suivants :

• Descendant de Workspace
• SpawnLocation.TeamColor est réglé sur Player.TeamColor ou SpawnLocation.Neutral

Si RespawnLocation n'est pas défini comme un SpawnLocation valide, la logique de génération par défaut s'appliquera. Pour plus d'informations à ce sujet, voir la page pour SpawnLocation.

Alternatives à RespawnLocation

• Un Player va apparaître à partir de SpawnLocations appartenant à leur équipe. Dans certains cas, il peut être plus simple de modifier le Player.Team du joueur à la place.
• Utilisez 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é de l'équipe est une référence à un objet Team dans le service Class.

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 avec quelle équipe un Joueur est associé en fonction de la valeur de Team.TeamColor de l'équipe. Changer cette propriété changera Player.Team selon le même BrickColor pour leur 1> Class.Team.TeamColor1> . Si aucun objet d'équ

Il est souvent une meilleure idée de définir Player.Team sur le respectif Team au lieu d'utiliser cette propriété. En définissant cette propriété, vous pouvez souvent entraîner la répétition de la même valeur BrickColor pour un certain équipe dans de nombreux scripts ; c'est quelque chose que vous voulez éviter lorsque vous adhérez au principe « Ne vous répétez pas » (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'UserId est une propriété Player qui contient un nombre entier lire seulement qui unique et cohérent identifie chaque compte d'utilisateur sur Roblox. Contrairement à la Instance.Name d'un Player, qui peut changer selon le nom d'utilisateur actuel de l'utilisateur, ce que ce value ne changera jamais pour le même compte.

Cette propriété est essentielle lors de l'enregistrement/du chargement des données du joueur à l'aide de GlobalDataStores. Utilisez le mot de clé du joueur comme clé de la boutique de données pour 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)

La fonction ClearCharacterAppearance supprime tous les Accessory, Shirt, Pants, 1> Class.CharacterMesh1> et <

Il ne supprime pas t-shirts , les maillages 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 renvoie la distance entre la tête du personnage et le point Vector3 donné. Elle renvoie 0 si le joueur n'a pas de Player.Character.

Ceci 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 le 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 décrivant comment le Joueur rejoint l'expérience. Le dictionnaire contient l'un des champs suivants :

<tbody>
  <tr>
    <th>Jeu de source</th>
    <td>number</td>
    <td>Le <code>Class.DataModel.GameId</code> de l'expérience que le <code>Joueur</code> a téléportée. Ne s'applique que 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 source</th>
    <td>number</td>
    <td>Le <code>Class.DataModel.PlaceId</code> du lieu où le <code>Joueur</code> se téléporte. Ne s'y présente que si le joueur se téléporte dans le lieu actuel et qu'un serveur appelle la fonction de téléportation.</td>
  </tr>

  <tr>
    <th>Joueur par référence</th>
    <td>number</td>
    <td>Le <code>Class.Player.UserId</code> du joueur qui a invité le joueur actuel dans l'expérience. Utilisez ces données pour identifier la logique de récompense de référence et déclencher la logique de récompense.</td>
  </tr>

  <tr>
    <th>Membres</th>
    <td>matrice</td>
    <td>Une tableau contenant les <code>Class.Player.UserId</code> numéros des utilisateurs téléportés avec le <code>Player</code> . Présent uniquement si le joueur s'est téléporté comme une partie d'un groupe.</td>
  </tr>

  <tr>
    <th>Téléportation des données</th>
    <td>variante</td>
    <td>Réflète le <code>teleportData</code> spécifié dans le téléport original. Utile pour partager des informations entre les serveurs que le joueur téléporte. Ne s'applique qu'à la version actuelle 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 de texte ou de JSON codée en clair qui contient les données de lancement spécifiées dans une URL ou un Class.ExperienceInviteOptions.LaunchData .</td>
  </tr>
</tbody>

Obtenez JoinData et TeleportData

Si un serveur initialise la téléportation du joueur, le dictionnaire que ce 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 les données 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 dans les 48 heures passées.
• Il est garanti d'avoir été envoyé avec ce Player .
• Le SourcePlaceId et le SourceGameId sont garantis d'être le lieu 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 viennent d'un emplacementapprouvé.

Puisque ces données sont transmises par le client, elles peuvent toujours être abusées par un exploiter. Les données sensibles telles que la monnaie du joueur doivent être transmises via une solution sécurisée comme Memory Stores.

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 renvoie la valeur Mouse utilisée par le client. L'instance de la souris du joueur peut être utilisée pour suivre l'entrée de la souris par le client, y compris les clics de bouton gauche et droite et les mouvements et les emplacements.

Le service UserInputService fournit des fonctions et des événements supplémentaires pour suivre l'entrée de l'utilisateur - spécialement pour les appareils qui ne 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 dans secondes. «Ping» est une mesure du temps pris pour envoyer les données du client au serveur, puis de retour. Il n' implique pas la déesarcznalisation des données ou le traitement.

Pour les scripts côté client LocalScripts, cette fonction ne peut être appelée que sur le Players.LocalPlayer. Cette fonction est utile pour identifier et déboguer les problèmes qui se produisent dans les scénarios de haute latence. Elle est également utile pour masquer la latence, telle que l'ajustement de la vitesse de lancer des animations 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 inclut des articles tels que le Shirt , le Pants et le Accessories .

Ceci est utile pour déterminer si l'apparence d'un joueur s'est chargée après qu'il se soit d'abord joint à la jeu, ce qui peut être suivi en utilisant 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 de ce joueur. Lorsque cela est vrai, le joueur est vérifié. La vérification inclut, mais n'est pas limitée, la non-vérification du numéro de téléphone non-VOIP ou de l'identifiant gouvernemental.

Lors de l'implémentation de IsVerified , exercez la prudence pour vous assurer que l'implémentation ne bloque pas inadvertiment tous les utilisateurs non vérifiés.

Notez que la méthode ne peut être appelée que sur le serveur d'arrière-plan. L'appeler du côté du client entraîne une erreur. De plus, cette méthode renvoie 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 gracieusement déconnecter un client et d'optionner un message à l'utilisateur déconnecté. Ceci est utile pour modérer les utilisateurs abusifs. Vous devriez seulement permettre aux utilisateurs spécifiques que vous confiez pour déclencher cette méthode sur d'autres utilisateurs.

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

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 Move Player provoque la marche du personnage du joueur dans la direction donnée jusqu'à ce qu'il s'arrête, ou interrompu par le joueur (en utilisant leurs contrôles).

Ceci est utile lorsque vous scriptez NPC Humanoids qui se déplace autour d'une carte - mais n'est pas contrôlé par l'entrée d'un joueur réel.

Remarquez que le deuxième argument de la fonction indique si le Vector3 fourni devrait déplacer le joueur par rapport aux coordonnées mondiales ( non ) ou le joueur's Camera ( 1> oui1>).

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)

La fonction SetAccountAge définit l'âge du joueur dans les jours.

Il est utilisé pour définir la propriété Player qui décrit la date à laquelle le compte d'un joueur a été enregistré dans les jours.

Ceci ne définira pas l'âge du joueur sur le compte, mais l'âge du compte lui-même par rapport à la création de celui-ci.

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)