Players

Active ou désactive les trois méthodes Players ( BanAsync(), UnbanAsync(), et GetBanHistoryAsync() ) qui composent l'API de bannissement.Cette propriété n'est pas scriptable et ne peut être modifiée qu'en studio.

Cette propriété indique si le chat à bulles est activé ou non. Elle est définie avec la méthode Players:SetChatStyle() en utilisant l'enumérateur Enum.ChatStyle.

Lorsque ce mode de chat est activé, le jeu affiche les conversations dans l'interface utilisateur de chat dans le coin supérieur gauche de l'écran.

Il existe deux autres modes de chat, Players.ClassicChat et un mode de chat où les deux chat classique et bulle sont activés.

Cette propriété indique si characters réapparaîtra automatiquement. La valeur par défaut est vraie.

Si cette propriété est désactivée (fausse), le joueur characters ne sera pas généré jusqu'à ce que la fonction Player:LoadCharacter() soit appelée pour chaque Player, y compris lorsque les joueurs rejoignent l'expérience.

Cela peut être utile dans des expériences où les joueurs ont des vies finies, comme des jeux compétitifs dans lesquels les joueurs ne réapparaissent pas jusqu'à la fin d'une manche de jeu.

local Players = game:GetService("Players")

-- Set CharacterAutoLoads to false
Players.CharacterAutoLoads = false

-- Remove player's character from workspace on death
Players.PlayerAdded:Connect(function(player)
	while true do
		local char = player.CharacterAdded:Wait()
		char.Humanoid.Died:Connect(function()
			char:Destroy()
		end)
	end
end)

-- Respawn all dead players once every 10 seconds
while true do
	local players = Players:GetChildren()

	-- Check if each player is dead by checking if they have no character, if dead load that player's character
	for _, player in pairs(players) do
		if not workspace:FindFirstChild(player.Name) then
			player:LoadCharacter()
		end
	end

	-- Wait 10 seconds until next respawn check
	task.wait(10)
end

Indique si le chat classique est activé ou non. Cette propriété est définie par la méthode Players:SetChatStyle() en utilisant l'enuméro Enum.ChatStyle.

Lorsque ce mode de chat est activé, le jeu affiche les conversations dans une bulle au-dessus de la tête de l'expéditeur.

Il existe deux autres modes de chat, Players.BubbleChat et un mode de chat où les deux chat classique et bulle sont activés.

Cette propriété de lecture se réfère à la Player dont le client exécute l'expérience.

Cette propriété n'est définie que pour LocalScripts et ModuleScripts requises par eux, puisqu'ils s'exécutent sur le client.Pour le serveur, sur lequel Script les objets exécutent leur code, cette propriété est nil .

Cette propriété détermine le nombre maximum de joueurs pouvant être sur un serveur.Cette propriété ne peut être définie que par les paramètres d'un emplacementspécifique sur le tableau de bord du créateur ou par les paramètres du jeu .

Cette propriété indique le nombre de joueurs auxquels le matchmaker de Roblox remplira les serveurs.Ce nombre sera inférieur au nombre maximum de joueurs ( Players.MaxPlayers ) pris en charge par l'expérience.

Cette propriété contrôle le temps, en secondes, qu'il faut pour qu'un joueur réapparaisse lorsque Players.CharacterAutoLoads est vrai. Elle est définie par défaut sur 5.0 secondes.

Cela est utile lorsque vous voulez changer la durée nécessaire pour réapparaître en fonction du type de votre expérience, mais que vous ne voulez pas gérer l'apparition des joueurs individuellement.

Bien que cette propriété puisse être définie à l'intérieur d'un Script , vous pouvez plus facilement la définir directement sur l'objet Players dans la fenêtre Explorateur de Studio.

Cette fonction fait que le joueur local discute le message donné.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.

Au lieu de cela, lors de la création d'un système de chat personnalisé, ou d'un système qui a besoin d'accès au chat, vous pouvez utiliser la fonction Chat du service Chat:Chat() au lieu de cela.

Paramètres

Retours

-- Command bar
game:GetService("Players"):Chat("Hello, world!") --Results in 'Hello, world!' appearing in the Chat log under your Player's name.

-- Script
local Players = game:GetService("Players")
Players:Chat("Hello, world!") --Errors

Cette fonction recherche chaque Player dans Players pour une dont le Player.UserId correspond à l'ID utilisateur donné.Si un tel joueur n'existe pas, il renvoie simplement nil .Il est équivalent à la fonction suivante :

local Players = game:GetService("Players")
local function getPlayerByUserId(userId)
	for _, player in Players:GetPlayers() do
		if player.UserId == userId then
			return player
		end
	end
end

Cette méthode est utile pour trouver l'acheteur d'un produit développeur en utilisant MarketplaceService.ProcessReceipt, qui fournit une table incluant l'ID utilisateur de l'acheteur et non une référence à l'objet Joueur lui-même.La plupart des jeux nécessiteront une référence au joueur afin d'accorder des produits.

Paramètres

Retours

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 MarketplaceService = game:GetService("MarketplaceService")
local DataStoreService = game:GetService("DataStoreService")
local Players = game:GetService("Players")

-- Data store setup for tracking purchases that were successfully processed
local purchaseHistoryStore = DataStoreService:GetDataStore("PurchaseHistory")

local productIdByName = {
	fullHeal = 123123,
	gold100 = 456456,
}

-- A dictionary to look up the handler function to grant a purchase corresponding to a product ID
-- These functions return true if the purchase was granted successfully
-- These functions must never yield since they're called later within an UpdateAsync() callback
local grantPurchaseHandlerByProductId = {
	[productIdByName.fullHeal] = function(_receipt, player)
		local character = player.Character
		local humanoid = character and character:FindFirstChild("Humanoid")

		-- Ensure the player has a humanoid to heal
		if not humanoid then
			return false
		end

		-- Heal the player to full Health
		humanoid.Health = humanoid.MaxHealth

		-- Indicate a successful grant
		return true
	end,

	[productIdByName.gold100] = function(_receipt, player)
		local leaderstats = player:FindFirstChild("leaderstats")
		local goldStat = leaderstats and leaderstats:FindFirstChild("Gold")

		if not goldStat then
			return false
		end

		-- Add 100 gold to the player's gold stat
		goldStat.Value += 100

		-- Indicate a successful grant
		return true
	end,
}

-- The core ProcessReceipt callback function
-- This implementation handles most failure scenarios but does not completely mitigate cross-server data failure scenarios
local function processReceipt(receiptInfo)
	local success, result = pcall(
		purchaseHistoryStore.UpdateAsync,
		purchaseHistoryStore,
		receiptInfo.PurchaseId,
		function(isPurchased)
			if isPurchased then
				-- This purchase was already recorded as granted, so it must have previously been handled
				-- Avoid calling the grant purchase handler here to prevent granting the purchase twice

				-- While the value in the data store is already true, true is returned again so that the pcall result variable is also true
				-- This will later be used to return PurchaseGranted from the receipt processor
				return true
			end

			local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
			if not player then
				-- Avoids granting the purchase if the player is not in the server
				-- When they rejoin, this receipt processor will be called again
				return nil
			end

			local grantPurchaseHandler = grantPurchaseHandlerByProductId[receiptInfo.ProductId]
			if not grantPurchaseHandler then
				-- If there's no handler defined for this product ID, the purchase cannot be processed
				-- This will never happen as long as a handler is set for every product ID sold in the experience
				warn(`No purchase handler defined for product ID '{receiptInfo.ProductId}'`)
				return nil
			end

			local handlerSucceeded, handlerResult = pcall(grantPurchaseHandler, receiptInfo, player)
			if not handlerSucceeded then
				local errorMessage = handlerResult
				warn(
					`Grant purchase handler errored while processing purchase from '{player.Name}' of product ID '{receiptInfo.ProductId}': {errorMessage}`
				)
				return nil
			end

			local didHandlerGrantPurchase = handlerResult == true
			if not didHandlerGrantPurchase then
				-- The handler did not grant the purchase, so record it as not granted
				return nil
			end

			-- The purchase is now granted to the player, so record it as granted
			-- This will later be used to return PurchaseGranted from the receipt processor
			return true
		end
	)

	if not success then
		local errorMessage = result
		warn(`Failed to process receipt due to data store error: {errorMessage}`)

		return Enum.ProductPurchaseDecision.NotProcessedYet
	end

	local didGrantPurchase = result == true
	return if didGrantPurchase
		then Enum.ProductPurchaseDecision.PurchaseGranted
		else Enum.ProductPurchaseDecision.NotProcessedYet
end

-- Set the callback; this can only be done once by one script on the server
MarketplaceService.ProcessReceipt = processReceipt

Cette fonction renvoie le Player associé au donné Player.Character ou nil si on ne peut pas en trouver.Il est équivalent à la fonction suivante :

local function getPlayerFromCharacter(character)
	for _, player in game:GetService("Players"):GetPlayers() do
		if player.Character == character then
			return player
		end
	end
end

Cette méthode est souvent utilisée lorsque quelque événement dans le personnage du joueur se déclenche (comme leur Class.Humanoid``Class.Humanoid.Died|dying ).Un tel événement pourrait ne pas faire référence directement à l'objet Joueur, mais cette méthode fournit un accès facile.L'inverse de cette fonction peut être décrite comme obtenir le personnage d'un joueur.Pour ce faire, accédez simplement à la propriété Personnage.

Paramètres

Retours

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

local PLAYER_NAME = "Nightriff"

local character = Workspace:FindFirstChild(PLAYER_NAME)
local player = Players:GetPlayerFromCharacter(character)

if player then
	print(`Player {player.Name} ({player.UserId}) is in the game`)
else
	print(`Player {PLAYER_NAME} is not in the game!`)
end

Cette méthode renvoie une table de tous les objets Player actuellement connectés.Il fonctionne de la même manière que Instance:GetChildren() sauf qu'il ne retourne que des objets Player trouvés sous Players .Lorsqu'il est utilisé avec une boucle for, il est utile pour itérer sur tous les joueurs dans un jeu.

local Players = game:GetService("Players")

for _, player in Players:GetPlayers() do
	print(player.Name)
end

Les scripts qui se connectent à Players.PlayerAdded essaient souvent de traiter chaque joueur qui se connecte au jeu.Cette méthode est utile pour itérer sur les joueurs déjà connectés qui ne tireraient pas PlayerAdded .L'utilisation de cette méthode garantit que aucun joueur ne soit manqué !

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print("Player: " .. player.Name)
end

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

Retours

local Players = game:GetService("Players")

local function onCharacterAdded(character)
	-- Give them sparkles on their head if they don't have them yet
	if not character:FindFirstChild("Sparkles") then
		local sparkles = Instance.new("Sparkles")
		sparkles.Parent = character:WaitForChild("Head")
	end
end

local function onPlayerAdded(player)
	-- Check if they already spawned in
	if player.Character then
		onCharacterAdded(player.Character)
	end
	-- Listen for the player (re)spawning
	player.CharacterAdded:Connect(onCharacterAdded)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Cette fonction détermine si BubbleChat et ClassicChat sont utilisés et indique à TeamChat et Chat quoi faire en utilisant l'enumérit Enum.ChatStyle.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.

Cette fonction est utilisée internement lorsque le mode de chat est défini par le jeu.

Paramètres

Retours

-- Command bar
game.Players:SetChatStyle(Enum.ChatStyle.Classic) -- Set's chat style to Classic

-- LocalScript
local Players = game:GetService("Players")
Players:SetChatStyle(Enum.ChatStyle.Classic) -- Errors

Cette fonction fait du chat Players.LocalPlayer le message donné, qui ne sera visible que par les utilisateurs de la même équipe.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.

Cette fonction est utilisée internement lorsque le Players.LocalPlayer envoie un message à leur équipe.

Paramètres

Retours

-- Command bar
game.Players:TeamChat("Hello World") -- Sends a "Hello World" message to all players on the local player's team

-- LocalScript
local Players = game:GetService("Players")
Players:TeamChat("Hello World") -- Errors

La méthode Players:BanAsync() vous permet de bannir facilement les utilisateurs qui enfreignent les directives de votre expérience.Vous pouvez spécifier la durée de l'interdiction, activer l'interdiction pour se propager à des comptes alternatifs suspectés et fournir un message à l'utilisateur interdit en conformité avec les lignes directrices d'utilisation.Vous devez également publier vos règles d'expérience quelque part accessible à tous les utilisateurs et fournir un moyen pour eux d'Faire appel.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.

Interdiction et messagerie

Les utilisateurs bannis seront immédiatement expulsés et empêchés de rejoindre vos expériences.Ils seront présentés avec une erreur affichant le temps restant sur leur interdiction et votre DisplayReason .Les systèmes arrière-plan de Roblox expulseront les joueurs sur tous les serveurs à partir des emplacementque vous spécifiez.DisplayReason peut avoir une longueur maximale de 400 caractères et est soumis à un filtresde texte.Pour plus d'informations sur le texte modal acceptable, voir messagerie de bannissement.

Lieux et univers

Par défaut, les interdictions s'étendent à tout endroit dans cet univers.Pour limiter la ban à seulement le lieu d'où cette API est appelée, configurez ApplyToUniverse à false .Cependant, si un utilisateur est banni au lieu de départ de l'univers, cela entraîne effectivement l'exclusion de l'utilisateur de l'ensemble de l'univers, indépendamment du fait qu'une interdiction universelle soit en place ou non.

Comptes alternatifs

Les utilisateurs jouent souvent sous plusieurs comptes différents, appelés comptes alternatifs ou comptes alt, qui sont parfois utilisés pour contourner les interdictions de compte.Pour vous aider à garder les utilisateurs interdits à l'écart, le comportement par défaut de cette API propagera toutes les interdictions de l'ensemble du compte source que vous avez interdit à l'un de leurs comptes alternatifs suspectés.Vous pouvez désactiver les propagations de bannissement aux comptes alternatifs en configurant ExcludeAltAccounts à true .

Durée du bannissement

Toutes les transgressions ne sont pas identiques, donc tous les bans ne devraient pas être de la même longueur.Cette API vous permet de configurer la durée de l'bannir, en secondes, avec le champ Duration.Pour spécifier un bannirpermanent, définissez le champ à -1 .Vous pouvez également vouloir configurer dynamiquement la durée de l'interdiction en fonction de l'historique des interdictions de l'utilisateur, que vous pouvez interroger en utilisant Players:GetBanHistoryAsync() .Par exemple, vous pouvez vouloir envisager le nombre de bans, la durée des bans précédentes, ou construire la logique à partir des notes que vous enregistrez sous PrivateReason qui peuvent comporter jusqu'à 1000 caractères et ne sont pas filtrées par le texte.PrivateReason les notes ne sont jamais partagées avec le client et peuvent être considérées comme sûres des attaquants.

Erreurs et ralentissement

Cette méthode lance un appel HTTP vers les services arrière-plan qui sont soumis à une restriction et peuvent échouer.Si vous appelez cette API avec plus d'une UserId, cette méthode tentera de faire l'appel HTTP pour chaque ID.Il agrégera ensuite tous les messages d'erreur et les joindra comme une liste séparée par une virgule.Par exemple, si cette méthode est invoquée pour cinq utilisateurs et que les demandes des utilisateurs avec UserIds 2 et 4 échouent, le message d'erreur suivant apparaît :

HTTP failure for UserId 2: Timedout, HTTP 504 (Service unavailable) failure for UserId 4: Service exception

Le message inclura toujours failure for UserId {} si c'est une erreur HTTP.

Exigence côté client

En raison des risques associés à l'interdiction des utilisateurs, cette méthode ne peut être appelée que sur le serveur d'expérience arrière-plan (les appels côté client entraîneront une erreur).Vous pouvez tester cette API dans Studio, pendant la créationscollaborative ou dans un test d'équipe, mais les interdictions ne s'appliqueront pas à la production.

Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.

Paramètres

Retours

local Players = game:GetService("Players")

if shouldBeBanned(player) then
	local banHistoryPages = Players:GetBanHistoryAsync(player.UserId)
	local duration = getNextBanDuration(banHistoryPages) -- Creator-implemented logic
	local config: BanConfigType = {
		UserIds = { player.UserId },
		Duration = duration,
		DisplayReason = "You violated community guideline #5",
		PrivateReason = "Put anything here that the user should not know but is helpful for your records",
		ExcludeAltAccounts = false,
		ApplyToUniverse = true,
	}

	local success, err = pcall(function()
		return Players:BanAsync(config)
	end)
	print(success, err)
end

Retourne un modèle de caractère équipé de tout ce qui est spécifié dans la description Humanoïde passée, et est R6 ou R15 comme spécifié par le type de rig.

Paramètres

Retours

game.Players:CreateHumanoidModelFromDescription(Instance.new("HumanoidDescription"), Enum.HumanoidRigType.R15).Parent =
	game.Workspace

Retourne un ensemble de configuration de modèle de caractère avec tout ce qui est équipé pour correspondre à l'avatar de l'utilisateur spécifié par l'ID renvoyé.Cela inclut si ce personnage est actuellement R6 ou R15.

Paramètres

Retours

game.Players:CreateHumanoidModelFromUserId(1).Parent = game.Workspace

Récupère l'historique des bans et des débans de tout utilisateur dans l'univers de l'expérience.Cette méthode renvoie une instance BanHistoryPages qui hérite de Pages.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.

Cet appel de fonction réussira seulement sur les serveurs de jeu en production et non sur les appareils clients ou dans Studio.

Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.

Paramètres

Retours

Cette fonction renvoie des informations sur l'avatar d'un joueur (ignorant l'équipment) sur le site Web de Roblox sous la forme d'un dictionnaire.Il ne doit pas être confondu avec GetCharacterAppearanceAsync , qui charge réellement les ressources décrites par cette méthode.Vous pouvez utiliser InsertService:LoadAsset() pour charger les ressources utilisées dans l'avatar du joueur.La structure du dictionnaire retourné est la suivante :

<th>Type</th>

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

<tr>
  <td><code>ressources</code></td>

  <td>table (voir ci-dessous)</td>

  <td>Décrit les ressources équipées (chapeaux, parties du corps, etc)</td>
</tr>

<tr>
  <td><code>couleurs du corps</code></td>

  <td>table (voir ci-dessous)</td>

  <td>Définit les valeurs de couleur brique pour chaque membre</td>
</tr>

<tr>
  <td><code>couleur du corps3s</code></td>

  <td>table (voir ci-dessous)</td>

  <td>Décrit l'instance Color3 pour chaque membre qui peut ne pas correspondre parfaitement aux couleurs du corps</td>
</tr>

<tr>
  <td><code>pantalons par défaut appliqués</code></td>

  <td>bool</td>

  <td>Détermine si des pantalons par défaut sont appliqués</td>
</tr>

<tr>
  <td><code>defaultShirtAppliqué</code></td>

  <td>bool</td>

  <td>Détermine si la chemise par défaut est appliquée</td>
</tr>

<tr>
  <td><code>émotes</code></td>

  <td>table (voir ci-dessous)</td>

  <td>Décrit les animations d'émote équipées</td>
</tr>

<tr>
  <td><code>type d'avatar du joueur</code></td>

  <td>chaîne</td>

  <td>Soit « R15 » ou « R6 »</td>
</tr>

<tr>
  <td><code>écailles</code></td>

  <td>table (voir ci-dessous)</td>

  <td>Décrit divers facteurs d'ajustement du corps</td>
</tr>

Tableau des ressources sous-table

La table assets est un tableau d'associations de tables contenant les clés suivantes qui décrivent les ressources actuellement équipées par le joueur :

<th>Type</th>

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

<tr>
  <td><code>id</code></td>

  <td>numéro</td>

  <td>L'ID de la ressource de la ressource équipée</td>
</tr>

<tr>
  <td><code>type de ressource</code></td>

  <td>tableau</td>

  <td>Une table avec les champs <code>nom</code> et <code>ID</code>, chacun décrivant le type de ressource équipée ("Chapeau", "Visage", etc.)</td>
</tr>

<tr>
  <td><code>nom</code></td>

  <td>chaîne</td>

  <td>Le nom de la contenu</td>
</tr>

Sous-tableau des échelles

La table scales a les clés suivantes, chacune correspondant à une propriété d'ajustement Humanoid : bodyType , head , height , proportion , depth , width .

Sous-tableau des couleurs du corps

La table bodyColors a les clés suivantes, chacune correspondant à un nombre correspondant à un numéro d'ID BrickColor qui peut être utilisé avec BrickColor.new(id) : leftArmColorId , torsoColorId , rightArmColorId , headColorId , leftLegColorId , rightLegColorId .

Paramètres

Retours

local result = {
	playerAvatarType = "R15",
	defaultPantsApplied = false,
	defaultShirtApplied = false,
	scales = {
		bodyType = 0,
		head = 1,
		height = 1.05,
		proportion = 0,
		depth = 0.92,
		width = 0.85,
	},
	bodyColors = {
		leftArmColorId = 1030,
		torsoColorId = 1001,
		rightArmColorId = 1030,
		headColorId = 1030,
		leftLegColorId = 1001,
		rightLegColorId = 1001,
	},
	assets = {
		{
			id = 1031492,
			assetType = {
				name = "Hat",
				id = 8,
			},
			name = "Striped Hat",
		},
		{
			id = 13062491,
			assetType = {
				name = "Face Accessory",
				id = 42,
			},
			name = "Vision Française ",
		},
		{
			id = 16598440,
			assetType = {
				name = "Neck Accessory",
				id = 43,
			},
			name = "Red Bow Tie",
		},
		{
			id = 28999228,
			assetType = {
				name = "Face",
				id = 18,
			},
			name = "Joyous Surprise",
		},
		{
			id = 86896488,
			assetType = {
				name = "Shirt",
				id = 11,
			},
			name = "Expensive Red Tuxedo Jacket",
		},
		{
			id = 86896502,
			assetType = {
				name = "Pants",
				id = 12,
			},
			name = "Expensive Red Tuxedo Pants",
		},
		{
			id = 376530220,
			assetType = {
				name = "Left Arm",
				id = 29,
			},
			name = "ROBLOX Boy Left Arm",
		},
		{
			id = 376531012,
			assetType = {
				name = "Right Arm",
				id = 28,
			},
			name = "ROBLOX Boy Right Arm",
		},
		{
			id = 376531300,
			assetType = {
				name = "Left Leg",
				id = 30,
			},
			name = "ROBLOX Boy Left Leg",
		},
		{
			id = 376531703,
			assetType = {
				name = "Right Leg",
				id = 31,
			},
			name = "ROBLOX Boy Right Leg",
		},
		{
			id = 376532000,
			assetType = {
				name = "Torso",
				id = 27,
			},
			name = "ROBLOX Boy Torso",
		},
	},
}

print(result)

La fonction GetFriends Players retourne un objet FriendPages qui contient des informations pour tous les amis de l'utilisateur donné.Les éléments de l'objet FriendPages sont des tables avec les champs suivants :

<th>Type</th>

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

<tr>
  <td>Id</td>

  <td>int64</td>

  <td>L'ID utilisateur de l'ami</td>
</tr>

<tr>
  <td>Nom d'utilisateur</td>

  <td>chaîne</td>

  <td>Le nom d'utilisateur de l'ami</td>
</tr>

<tr>
  <td>Nom à afficher</td>

  <td>chaîne</td>

  <td>Le <code>Class.Player.DisplayName|nom d'affichage du ami</code> de l'ami.</td>
</tr>

Voir les échantillons de code pour une façon facile d'itérer sur tous les amis d'un joueur.

Paramètres

Retours

local Players = game:GetService("Players")

local USERNAME = "Cozecant"

local function iterPageItems(pages)
	return coroutine.wrap(function()
		local pagenum = 1
		while true do
			for _, item in ipairs(pages:GetCurrentPage()) do
				coroutine.yield(item, pagenum)
			end
			if pages.IsFinished then
				break
			end
			pages:AdvanceToNextPageAsync()
			pagenum = pagenum + 1
		end
	end)
end

-- First, get the user ID of the player
local userId = Players:GetUserIdFromNameAsync(USERNAME)
-- Then, get a FriendPages object for their friends
local friendPages = Players:GetFriendsAsync(userId)
-- Iterate over the items in the pages. For FriendPages, these
-- are tables of information about the friend, including Username.
-- Collect each username in a table
local usernames = {}
for item, _pageNo in iterPageItems(friendPages) do
	table.insert(usernames, item.Username)
end

print("Friends of " .. USERNAME .. ": " .. table.concat(usernames, ", "))

Retourne la description humanoïde pour un ID de tenue spécifié, qui sera défini avec les parties/couleurs/animations etc. de la tenue.Une tenue peut être créée par un utilisateur, ou elle peut être la tenue pour un paquet créé par Roblox.

Paramètres

Retours

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

local function getOutfitId(bundleId)
	if bundleId <= 0 then
		return
	end
	local info = game.AssetService:GetBundleDetailsAsync(bundleId)
	if not info then
		return
	end
	for _, item in pairs(info.Items) do
		if item.Type == "UserOutfit" then
			return item.Id
		end
	end

	return nil
end

local function getHumanoidDescriptionBundle(bundleId)
	local itemId = getOutfitId(bundleId)
	if itemId and itemId > 0 then
		return Players:GetHumanoidDescriptionFromOutfitId(itemId)
	end

	return nil
end

local humanoidDescription = getHumanoidDescriptionBundle(799)
local humanoidModel = Players:CreateHumanoidModelFromDescription(humanoidDescription, Enum.HumanoidRigType.R15)
humanoidModel.Parent = Workspace

Renvoie une description humanoïde qui spécifie tout ce qui est équipé pour l'avatar de l'utilisateur spécifié par l'ID renvoyé.Comprend également les écailles et les couleurs du corps.

Paramètres

Retours

game.Players:CreateHumanoidModelFromDescription(
	game.Players:GetHumanoidDescriptionFromUserId(1),
	Enum.HumanoidRigType.R15
).Parent =
	game.Workspace

La fonction GetNameFromUserIdAsync Players enverra une requête au site Web Roblox pour demander quel est le nom d'utilisateur du compte avec le mot donné UserId.

Cette méthode échoue si aucun compte n'existe avec l'ID utilisateur donné.Si vous n'êtes pas sûr qu'un tel compte existe, il est recommandé d'envelopper les appels à cette fonction avec pcall() .En outre, vous pouvez cacher manuellement les résultats pour effectuer des appels futurs avec le même UserId rapidement.Voir les échantillons de code pour en savoir plus.

Paramètres

Retours

local Players = game:GetService("Players")

-- Example Data:
-- UserId: 118271    Name: "RobloxRulez"
-- UserId: 131963979 Name: "docsRule"

local nameOne = Players:GetNameFromUserIdAsync(118271)
local nameTwo = Players:GetNameFromUserIdAsync(131963979)

print(nameOne, nameTwo)
-- prints: "RobloxRulez docsRule"

local Players = game:GetService("Players")

-- Create a table called 'cache' to store each 'Name' as they are found.
-- If we lookup a 'Name' using the same 'UserId', the 'Name' will come
-- from cache (fast) instead of GetNameFromUserIdAsync() (yields).
local cache = {}

function getNameFromUserId(userId)
	-- First, check if the cache contains 'userId'
	local nameFromCache = cache[userId]
	if nameFromCache then
		-- if a value was stored in the cache at key 'userId', then this 'nameFromCache'
		-- is the correct Name and we can return it.
		return nameFromCache
	end

	-- If here, 'userId' was not previously looked up and does not exist in the
	-- cache. Now we need to use GetNameFromUserIdAsync() to look up the name
	local name
	local success, _ = pcall(function()
		name = Players:GetNameFromUserIdAsync(userId)
	end)
	if success then
		-- if 'success' is true, GetNameFromUserIdAsync() successfully found the
		-- name. Store this name in the cache using 'userId' as the key so we
		-- never have to look this name up in the future. Then return name.
		cache[userId] = name
		return name
	end
	-- If here, 'success' was false, meaning GetNameFromUserIdAsync()
	-- was unable to find the 'name' for the 'userId' provided. Warn the user
	-- this happened and then return nothing, or nil.
	warn("Unable to find Name for UserId:", userId)
	return nil
end

-- Example Data:
-- UserId: 118271    Name: "RobloxRulez"
-- UserId: 131963979 Name: "docsRule"

-- The first time a UserId is used, GetNameFromUserIdAsync() will be called
local nameOne = getNameFromUserId(118271)
local nameTwo = getNameFromUserId(131963979)
-- Because 118271 was previously used, get its Name from the cache
local nameOneQuick = getNameFromUserId(118271)

print(nameOne, nameTwo, nameOneQuick)
-- prints: "RobloxRulez docsRule RobloxRulez"

Cette fonction enverra une requête au site Web Roblox pour demander ce que le Player.UserId est de l' compte avec le nom donné Player.

Cette méthode échoue si aucun compte n'existe avec le nom d'utilisateur donné.Si vous n'êtes pas sûr qu'un tel compte existe, il est recommandé d'envelopper les appels à cette fonction avec pcall() .En outre, vous pouvez cacher manuellement les résultats pour effectuer rapidement des appels futurs avec le même nom d'utilisateur.Voir les échantillons de code pour en savoir plus.

Paramètres

Retours

local Players = game:GetService("Players")

-- Example Data:
-- UserId: 118271    Name: "RobloxRulez"
-- UserId: 131963979 Name: "docsRule"

local userIdOne = Players:GetUserIdFromNameAsync("RobloxRulez")
local userIdTwo = Players:GetUserIdFromNameAsync("docsRule")
print(userIdOne, userIdTwo)
-- prints: "118271 131963979"

local Players = game:GetService("Players")

-- Create a table called 'cache' to store each 'UserId' as they are found.
-- If we lookup a 'UserId' using the same 'Name', the 'UserId' will come
-- from cache (fast) instead of GetUserIdFromNameAsync() (yields).
local cache = {}

function getUserIdFromName(name)
	-- First, check if the cache contains 'name'
	local userIdFromCache = cache[name]
	if userIdFromCache then
		-- if a value was stored in the cache at key 'name', then this 'userIdFromCache'
		-- is the correct UserId and we can return it.
		return userIdFromCache
	end

	-- If here, 'name' was not previously looked up and does not exist in the
	-- cache. Now we need to use GetUserIdFromNameAsync() to look up the userId
	local userId
	local success, _ = pcall(function()
		userId = Players:GetUserIdFromNameAsync(name)
	end)
	if success then
		-- if 'success' is true, GetUserIdFromNameAsync() successfully found the
		-- userId. Store this userId in the cache using 'name' as the key so we
		-- never have to look this userId up in the future. Then return userId.
		cache[name] = userId
		return userId
	end
	-- If here, 'success' was false, meaning GetUserIdFromNameAsync()
	-- was unable to find the 'userId' for the 'name' provided. We can warn the
	-- user this happened and then return nothing, or nil.
	warn("Unable to find UserId for Name:", name)
	return nil
end

-- Example Data:
-- UserId: 118271    Name: "RobloxRulez"
-- UserId: 131963979 Name: "docsRule"

-- The first time a Name is used, GetUserIdFromNameAsync() will be called
local userIdOne = getUserIdFromName("RobloxRulez")
local userIdTwo = getUserIdFromName("docsRule")
-- Because "RobloxRulez" was previously used, get its UserId from the cache
local userIdOneQuick = getUserIdFromName("RobloxRulez")

print(userIdOne, userIdTwo, userIdOneQuick)
-- prints: "118271 131963979 118271"

Cette fonction renvoie l'URL du contenu d'une image de l'avatar d'un joueur donnée leur UserId , la taille d'image souhaitée en tant qu'enumérateur Enum.ThumbnailSize , et le type souhaité en tant qu'enumérateur Enum.ThumbnailType.Il renvoie également un booléen décrivant si l'image est prête à l'utilisation.

La plupart du temps, cette méthode est utilisée avec ImageLabel.Image ou Decal.Texture pour afficher des images d'avatar d'utilisateur dans une expérience.

Paramètres

Retours

local Players = game:GetService("Players")

local player = Players.LocalPlayer

local PLACEHOLDER_IMAGE = "rbxassetid://0" -- replace with placeholder image

-- fetch the thumbnail
local userId = player.UserId
local thumbType = Enum.ThumbnailType.HeadShot
local thumbSize = Enum.ThumbnailSize.Size420x420
local content, isReady = Players:GetUserThumbnailAsync(userId, thumbType, thumbSize)

-- set the ImageLabel's content to the user thumbnail
local imageLabel = script.Parent
imageLabel.Image = (isReady and content) or PLACEHOLDER_IMAGE
imageLabel.Size = UDim2.new(0, 420, 0, 420)

Débannir les joueurs bannis de ou de l'API de cloud ouvert des restrictions d'utilisateur .Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.

Comme Players:BanAsync(), cette méthode prend un dictionnaire config qui vous permettra de masser débannir les utilisateurs.Cela configure les utilisateurs qui sont débannés et la portée à partir de laquelle ils sont débannés.

Les débans n'auront d'effet que sur les interdictions ayant le même champ ApplyToUniverse .Par exemple, un débannissement avec ApplyToUniverse défini sur true ne rendra pas un précédent bannissement avec ApplyToUniverse défini sur false invalide.En d'autres termes, un déban au niveau de l'univers ne rendra pas un bannirau niveau d'un lieu invalide.L'inverse est également vrai.

Cette méthode lance un appel HTTP vers les services arrière-plan, qui sont limités et peuvent échouer.Si vous appelez cette API avec plusieurs UserIds, cette méthode tentera de faire cette requête HTTP pour chaque UserId.Il agrégera ensuite tous les messages d'erreur et les joindra comme une liste séparée par une virgule.Par exemple, si cette méthode est invoquée pour cinq UserIds : {1, 2, 3, 4, 5} et que les demandes pour les utilisateurs 2 et 4 échouent, le message d'erreur suivant apparaît : HTTP failure for UserId 2: Timedout, HTTP 504 (Service unavailable) failure for UserId 4: Service exception. Le message inclura toujours failure for UserId {} si c'est une erreur HTTP.C'est un comportement non défini si vous passez à la fois des UserIds valides et invalides, c'est-à-direun UserId qui n'est pas un nombre positif, car certaines demandes réseau peuvent réussir avant que toute entrée soit validée.

En raison des risques associés à l'interdiction des utilisateurs, cette méthode ne peut être appelée que sur le serveur de jeu arrière-plan.Les appels côté client entraîneront une erreur.Vous pouvez tester cette API dans Studio, création d'équipe et test d'équipe, mais les interdictions ne s'appliqueront pas à la production.Cet appel de fonction ne tentera que des demandes d'interdiction sur les serveurs de jeu en production et non dans le test de Studio.Cependant, toutes les étapes de validation d'entrée fonctionneront toujours dans Studio.

Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.

Paramètres

<th>Type</th>

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

<tbody>
  <tr>
    <td><code>ID utilisateur</code></td>

    <td>matrice</td>

    <td>Les ID d'utilisateur doivent être forcés dans l'expérience(s). La taille maximale est de <code>50</code> .</td>
  </tr>

  <tr>
    <td><code>Appliquer à l'univers</code></td>

    <td>booléen</td>

    <td>Propague le déban à tous les endroits dans cet univers.</td>
  </tr>
</tbody>

Retours

local Players = game:GetService("Players")

if shouldBeUnbanned(player) then
	local config: UnbanConfigType = {
		UserIds = { player.UserId, 789 },
		ApplyToUniverse = false,
	}
	local success, err = pcall(function()
		return Players:UnbanAsync(config)
	end)
	print(success, err)
end

Cet événement se déclenche lorsqu'un joueur entre dans le jeu.Ceci est utilisé pour déclencher un événement lorsqu'un joueur rejoint un jeu, comme le chargement des données sauvegardées du joueur GlobalDataStore.

Cela peut être utilisé en même temps que l'événement Players.PlayerRemoving, qui se déclenche lorsqu'un joueur est sur le point de quitter le jeu.Par instance, si vous souhaitez imprimer un message chaque fois qu'un nouveau joueur rejoint ou quitte le jeu :

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	print(player.Name .. " joined the game!")
end)

Players.PlayerRemoving:Connect(function(player)
	print(player.Name .. " left the game!")
end)

Si vous souhaitez suivre quand le personnage d'un joueur est ajouté ou supprimé du jeu, comme lorsqu'un joueur réapparaît ou meurt, vous pouvez utiliser les fonctions Player.CharacterAdded et Player.CharacterRemoving.

Notez que cet événement ne fonctionne pas comme prévu en mode lecture car le joueur est créé avant que les scripts se connectent à PlayerAdded.Pour gérer ce cas, ainsi que les cas dans lesquels le script est ajouté dans le jeu après l'entrée d'un joueur, créez une fonction onPlayerAdded() que vous pouvez appeler pour gérer l'entrée d'un joueur.

Paramètres

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print("A player has entered: " .. player.Name)
end

Players.PlayerAdded:Connect(onPlayerAdded)

Cet événement se déclenche lorsque le serveur de jeu reconnaît que l'adhésion d'un joueur a changé.Remarquez cependant que le serveur ne tentera de vérifier et de mettre à jour l'adhésion après que la modalité Premium a été fermée.Ainsi, pour tenir compte des cas où l'utilisateur achète Premium en dehors du jeu pendant qu'il joue, vous devez toujours les inciter à acheter Premium ; cela montrera ensuite un message leur indiquant qu'ils sont déjà améliorés et, une fois qu'ils ferment la modalité, le serveur de jeu mettra à jour leur adhésion et déclenchera cet événement.

Pour en savoir plus sur et intégrer Premium dans votre expérience et monétiser avec le système de paiements basé sur l'engagement, voir paiements basés sur l'engagement.

Voir aussi :

• MarketplaceService:PromptPremiumPurchase() , utilisé pour inciter un utilisateur à acheter Premium
• MarketplaceService.PromptPremiumPurchaseFinished , se déclenche lorsque l'interface utilisateur d'achat premium se ferme

Paramètres

local Players = game:GetService("Players")

local function grantPremiumBenefits(player)
	-- Grant the player access to Premium-only areas, items, or anything you can imagine!
	print("Giving", player, "premium benefits!")
end

local function playerAdded(player)
	if player.MembershipType == Enum.MembershipType.Premium then
		grantPremiumBenefits(player)
	end
end

local function playerMembershipChanged(player)
	print("Received event PlayerMembershipChanged. New membership = " .. tostring(player.MembershipType))
	if player.MembershipType == Enum.MembershipType.Premium then
		grantPremiumBenefits(player)
	end
end

Players.PlayerAdded:Connect(playerAdded)
Players.PlayerMembershipChanged:Connect(playerMembershipChanged)

L'événement PlayerRemoving se déclenche juste avant qu'un Player quitte le jeu.Cet événement se déclenche avant que ChildRemoved ne fasse sur Players , et se comporte de manière similaire à Instance.DescendantRemoving .Puisqu'il se déclenche avant l'élimination réelle d'un Player , cet événement est utile pour stocker les données du joueur en utilisant un GlobalDataStore .

Cela peut être utilisé en même temps que l'événement Player.PlayerAdded, qui se déclenche lorsqu'un joueur rejoint le jeu.Par instance, pour imprimer un message chaque fois qu'un nouveau joueur rejoint ou quitte le jeu :

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	print(player.Name .. " joined the game!")
end)

Players.PlayerRemoving:Connect(function(player)
	print(player.Name .. " left the game!")
end)

Si vous souhaitez suivre quand le personnage d'un joueur est ajouté ou supprimé du jeu, comme lorsqu'un joueur réapparaît ou meurt, vous pouvez utiliser les fonctions Player.CharacterAdded et Player.CharacterRemoving.

Paramètres

local Players = game:GetService("Players")

local function onPlayerRemoving(player)
	print("A player has left: " .. player.Name)
end

Players.PlayerRemoving:Connect(onPlayerRemoving)

Cet événement se déclenche lorsque le serveur de jeu reconnaît que le statut de l'utilisateur pour un certain abonnement a changé.Notez que le serveur ne tente de vérifier et de mettre à jour le statut qu'après que la modalité d'achat d'abonnement a été fermée.Pour tenir compte des cas dans lesquels l'utilisateur achète l'abonnement en dehors du jeu pendant qu'il joue, vous devez toujours les inciter à acheter l'abonnement ; la demande affiche un message indiquant à l'utilisateur qu'il est déjà abonné, et après qu'il ferme la modalité, le serveur de jeu met à jour son statut d'abonnement et déclenche cet événement.

Notez que seuls les scripts du serveur reçoivent cet événement.

Paramètres