Players

La propriété BubbleChat indique si oui ou non le chat à bulles est activé. Elle est définie avec la méthode Players:SetChatStyle() en utilisant le coffre Enum.ChatStyle.

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

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

La propriété CharacterAutoLoads indique si Class.Character|Characters réapparaîtra automatiquement. La valeur par défaut est vraie.

Si cette propriété est désactivée (fausse), le joueur Class.Character|Characters ne s'affichera pas jusqu'à ce que la fonction Player:LoadCharacter() soit appelée pour chaque Player, y compris lorsque les joueurs rejoignent l'expérience.

Ceci peut être utile dans les expériences où les joueurs ont des vies finies, telles que les jeux compétitifs dans lesquels les joueurs ne réapparaissent pas jusqu'à la fin d'un tour 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 oui ou non le chat classique est activé. Cette propriété est définie par la méthode Players:SetChatStyle() utilisant l'encemble 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 y a deux autres modes de chat, Players.BubbleChat et un mode de chat où les chat classique et le chat bulle sont activés.

LocalPlayer est une propriété de lecture qui se réfère au Player dont le client exécute l'expérience.

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

La propriété MaxPlayers détermine le nombre max de joueurs qui peuvent être dans un serveur. Cette propriété ne peut être définie que via les paramètres d'un emplacementspécifique sur la MaxPlayers ou via les paramètres d'un jeu .

La propriété PreferredPlayers indique le nombre de joueurs auquel 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.

La propriété RespawnTime contrôle le temps, en secondes, qu'il faut pour qu'un joueur réapparaisse lorsque Players.CharacterAutoLoads est vrai. Il s'agit par défaut de 5 secondes.

Ceci est utile lorsque vous voulez changer la durée de réapparition en fonction du type d'expérience mais que vous ne voulez pas gérer le spawning des joueurs individuellement.

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

Cette fonction fait en sorte que le chat du joueur local devienne le message donné. Étant que cet élément est protégé, l'utilisation de l'objet dans un Script ou un 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 nécessite l'accès au chat, vous pouvez utiliser la fonction Chat du service Chat:Chat() à la place.

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 l'un dont le Player.UserId correspond à l'identifiant donné. Si un tel joueur n'existe pas, il renvoie simplement 1> nil1>. C'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 de développeur en utilisant MarketplaceService.ProcessReceipt, qui fournit une table qui inclut l'ID de l'acheteur et non une référence à l'objet Player lui-même. La plupart des jeux nécessiteront une référence au joueur pour 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 for tracking purchases that were successfully processed
local purchaseHistoryStore = DataStoreService:GetDataStore("PurchaseHistory")

-- Table setup containing product IDs and functions for handling purchases
local productFunctions = {}
-- ProductId 123123 for a full heal
productFunctions[123123] = function(_receipt, player)
	-- Logic/code for player buying a full heal (may vary)
	if player.Character and player.Character:FindFirstChild("Humanoid") then
		-- Heal the player to full health
		player.Character.Humanoid.Health = player.Character.Humanoid.MaxHealth
		-- Indicate a successful purchase
		return true
	end
end
-- ProductId 456456 for 100 gold
productFunctions[456456] = function(_receipt, player)
	-- Logic/code for player buying 100 gold (may vary)
	local stats = player:FindFirstChild("leaderstats")
	local gold = stats and stats:FindFirstChild("Gold")
	if gold then
		gold.Value = gold.Value + 100
		-- Indicate a successful purchase
		return true
	end
end

-- The core 'ProcessReceipt' callback function
local function processReceipt(receiptInfo)
	-- Determine if the product was already granted by checking the data store
	local playerProductKey = receiptInfo.PlayerId .. "_" .. receiptInfo.PurchaseId
	local purchased = false
	local success, result, errorMessage

	success, errorMessage = pcall(function()
		purchased = purchaseHistoryStore:GetAsync(playerProductKey)
	end)
	-- If purchase was recorded, the product was already granted
	if success and purchased then
		return Enum.ProductPurchaseDecision.PurchaseGranted
	elseif not success then
		error("Data store error:" .. errorMessage)
	end

	-- Determine if the product was already granted by checking the data store  
	local playerProductKey = receiptInfo.PlayerId .. "_" .. receiptInfo.PurchaseId

	local success, isPurchaseRecorded = pcall(function()
		return purchaseHistoryStore:UpdateAsync(playerProductKey, function(alreadyPurchased)
			if alreadyPurchased then
				return true
			end

			-- Find the player who made the purchase in the server
			local player = Players:GetPlayerByUserId(receiptInfo.PlayerId)
			if not player then
				-- The player probably left the game
				-- If they come back, the callback will be called again
				return nil
			end

			local handler = productFunctions[receiptInfo.ProductId]

			local success, result = pcall(handler, receiptInfo, player)
			-- If granting the product failed, do NOT record the purchase in datastores.
			if not success or not result then
				error("Failed to process a product purchase for ProductId: " .. tostring(receiptInfo.ProductId) .. " Player: " .. tostring(player) .. " Error: " .. tostring(result))
				return nil
			end

			-- Record the transaction in purchaseHistoryStore.
			return true
		end)
	end)

	if not success then
		error("Failed to process receipt due to data store error.")
		return Enum.ProductPurchaseDecision.NotProcessedYet
	elseif isPurchaseRecorded == nil then
		-- Didn't update the value in data store.
		return Enum.ProductPurchaseDecision.NotProcessedYet
	else	
		-- IMPORTANT: Tell Roblox that the game successfully handled the purchase
		return Enum.ProductPurchaseDecision.PurchaseGranted
	end
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é avec le Player.Character donné, ou nil si on ne peut pas le trouver. C'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 l'un des événements dans le personnage du joueur se déclenche (tels que leur Class.Humanoid``Class.Humanoid.Died|dying). Un tel événement peut ne pas référencer directement l'objet Player, mais cette méthode fournit un accès facile. Le contraire de cette fonction peut être décrit comme obtenir le Character d'un joueur. Pour le faire, accédez simplement à la propriété

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. Elle fonctionne de la même façon que Instance:GetChildren() excepté qu'elle ne renvoie que les objets Player trouvés sous 1> Class.Players1>. Lorsqu'elle est utilisée avec un boucle de rétro1>,

local Players = game:GetService("Players")

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

Les scripts qui se connectent à Players.PlayerAdded sont souvent en train 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 se déclencheront pas PlayerAdded . En utilisant cette méthode, vous garantissez que aucun joueur n'est 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 qu'il doit agir en utilisant l'encemble Class.ChatStyle . Étant que cet élément est protégé, l'essayer d'utiliser dans un Enum.ChatStyle ou Script 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 en sorte que le chat Players.LocalPlayer affiche le message donné, qui ne sera visible que par les utilisateurs sur le même équipe. Étant que cet élément est protégé, l'utilisation de celui-ci dans un Script ou LocalScript entraînera 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 lignes directrices de votre expérience. Vous pouvez spécifier la durée de la banne, activer la banne pour se propager sur les comptes suspects et fournir un message à l'utilisateur banni en vertu des lignes directrices d'utilisation . Vous devriez également publier vos règles d'expérience

Ban et messagerie

Les utilisateurs interdits seront immédiatement expulsés et empêchés de rejoindre vos expériences. Ils recevront une erreur modale affichant le temps restant sur leur interdiction et votre DisplayReason. Les systèmes de base de Roblox peuvent expulser les joueurs sur tous les serveurs que vous spécifiez. DisplayReason peut avoir une longueur

Lieux et univers

Par défaut, les interdictions s'étendent à n'importe quel endroit dans cet univers. Pour limiter la banne à un endroit spécifique à partir duquel cette API est appelée, configurez ApplyToUniverse pour false . Cependant, si un utilisateur est interdit dans le lieu de départ de l'univers, il résulte effectivement que l'utilisateur soit exclu de l'ensemble de l'univers, indépendamment de la présence d'un b

Comptes alternatifs

Les utilisateurs jouent souvent sous plusieurs comptes différents, connus sous le nom de comptes alternatifs ou comptes alt, qui sont parfois utilisés pour contourner les interdictions de compte. Pour vous aider à garder les utilisateurs exclus de sortie, le comportement par défaut de cette API propagera tous les bans de l' compte source que vous avez banni à n'importe lequel de leurs comptes suspects. Vous pouvez désactiver les propagations de bans à alt en configurant ExcludeAltAccount

Durée de la Ban

Non pas toutes les transgressions ne sont pas les mêmes, donc les interdictions ne do

Erreurs et accélération

Cette méthode invite un appel HTTP aux services de l'arrière-plan qui sont soumis à une limite et peuvent échouer. Si vous appelez cette API avec plus d'un UserId , cette méthode tentera de faire le call HTTP pour chaque ID. Elle agrégera ensuite les messages d'erreur et les rejoindra comme une liste séparée par des virg

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 à la禁止 des utilisateurs, cette méthode ne peut être appelée que sur le serveur d'expérience de banque de données (les appels côté client entraîneront une erreur). Vous pouvez tester cette API dans Studio, pendant collaborative la créations, ou dans un test de l'équipe , mais les bans ne s'appliqueront pas à la production.

Cette API utilise l' API utilisateur restreintes Open Cloud. Vous pourrez utiliser ces API pour gérer vos interdictions dans des applications tierces.

Paramètres

Retours

local Players = game:GetService("Players")

if shouldBeBanned(player: 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

Renvoie un modèle de personnage équipé avec tout ce qui est spécifié dans la description d'humanoïde, 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

Renvoie un ensemble de modèles de personnage avec tout ce qui est équipé pour correspondre à l'avatar de l'utilisateur spécifié par l'identifiant de l'utilisateur. 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 de ban et d'annulation de n'importe quel utilisateur dans l'univers de l'expérience. Ce méthode renvoie une instance BanHistoryPages qui hérite de Pages .

Ce appel de fonction ne réussira que sur les serveurs de jeu production et non sur les appareils clients ou dans Studio.

Cette API utilise l' API utilisateur restreintes Open Cloud. Vous pourrez 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 dans la forme d'un dictionnaire. Il ne s'agit pas de confondre avec GetCharacterAppearanceAsync , qui charge en fait les ressources décrites par cette méthode. Vous pouvez utiliser Class.InsertService

<tr>
  <td><code>ressources</code></td>
  <td>table (voir ci-dessous)</td>
  <td>Décrivez 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écrivez les valeurs BrickColor pour chaque membre</td>
</tr>

<tr>
  <td><code>couleur du corps3s</code></td>
  <td>table (voir ci-dessous)</td>
  <td>Décrivez l'instance Color3 pour chaque membre qui peut ne pas correspondre parfaitement aux couleurs du corps</td>
</tr>

<tr>
  <td><code>pantalon d'application par défaut</code></td>
  <td>bulle</td>
  <td>Détermine si les pantalons par défaut sont appliqués</td>
</tr>

<tr>
  <td><code>chemise par défaut appliquée</code></td>
  <td>bulle</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écrire les animations d'emote é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écrivez divers facteurs de mise à l'échelle du corps</td>
</tr>

Assets Sub-Table

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

<tr>
  <td><code>id)</code></td>
  <td>number</td>
  <td>L'ID de la ressource de l'actif contenu</td>
</tr>

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

<tr>
  <td><code>nom稱</code></td>
  <td>chaîne</td>
  <td>Le nom de l'élément contenu</td>
</tr>

Redimensionne Sub-Table

La table scales a les clés suivantes, chacune correspondant à une propriété de Humanoid échelonnement : bodyType, 1>head1>, 4> height4>, 7> proportion7>, 9> depth9>, 0> width0>.

Couleurs de corps souterrain

La table bodyColors a les clés suivantes, chacune correspondant à un BrickColor ID numéro qui peut être utilisé avec BrickColor.new(id) : 2>tor

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 renvoie un objet FriendPages qui contient des informations sur tous les amis donné de l'utilisateur. Les éléments dans l'objet FriendPages sont des tables avec les champs suivants :

<tr>
  <td>Identifiant</td>
  <td>int64</td>
  <td>L'identifiant de l'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 d'affichage</td>
  <td>chaîne</td>
  <td>Le <code>Nom du Class.Player.DisplayName|nom du display</code> du 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, ", "))

Renvoie la description du humanoid pour un identifiant 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 il peut s'agir de la tenue pour un ensemble 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'identifiant de l'utilisateur. 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 envoie une requête sur le site Web de Roblox en demandant quelle est l'identifiant de l'utilisateur du compte avec le UserId donné.

Cette méthode échoue si aucun compte n'existe avec l'identifiant de l'utilisateur donné. Si vous n'êtes pas sûr qu'un tel compte existe, il est recommandé d'embêcher les appels à cette fonction avec pcall. En outre, vous pouvez manuellement enregistrer les résultats pour futurs appels avec le même identifiant d'utilisateur rapidement. Voir les exemples 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 envoie une requête sur le site Web de Roblox pour demander ce que le Player.UserId est du 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'embêcher les appels à cette fonction avec pcall . En outre, vous pouvez manuellement stocker les résultats pour rapidement faire des appels avec le même nom d'utilisateur. Voir les exemples 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 d'avatar d'un joueur donné son UserId , la taille de l'image souhaitée en tant que Enum.ThumbnailSize枚枚, et le type souhaité en tant que Enum.ThumbnailType枚枚. Elle renvoie également un bool déterminant si l'image est prête à l'utilisation.

Le plus souvent, cette méthode est utilisée avec ImageLabel.Image ou Decal.Texture pour afficher les photos d'avatar de l'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 Players:BanAsync() ou de la API de restauration des restrictions d'utilisation .

Comme Players:BanAsync() , cette méthode prend un dictionnaire config qui vous permettra de débloquer des utilisateurs. Cela configurera les utilisateurs qui ne sont pas débloqués et le champ d'application dans lequel ils sont débloqués.

Les débans ne prendront effet que sur les interdictions avec le même ApplyToUniverse scope. Par exemple, un déban avec ApplyToUniverse défini sur true ne sera pas invalider un interdit avec 2> ApplyToUniverse2> défini sur 5> false5>. En

Cette méthode invite un appel HTTP vers les services de l'arrière-plan, qui sont limités et peuvent échouer. Si vous appelez cette API avec plusieurs UserIDs, cette méthode tentera de faire ce call HTTP pour chaque UserID. Elle affichera alors les

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

Cette API utilise l' API utilisateur restreintes Open Cloud. Vous pourrez utiliser ces API pour gérer vos interdictions dans des applications tierces.

Paramètres

<tbody>
  <tr>
    <td><code>UserIds</code></td>
    <td>matrice</td>
    <td>UserIDs à autoriser dans l'expérience(s). La taille maximale est de <code>50</code> .</td>
  </tr>

  <tr>
    <td><code>Appliquer à l'univers</code></td>
    <td>boîtier</td>
    <td>Propagate l'unban dans tous les endroits dans cet univers.</td>
  </tr>
</tbody>

Retours

local Players = game:GetService("Players")

if shouldBeUnbanned(player: 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

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

Ceci peut être utilisé avec 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 voulez suivre quand un personnage de 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.

Remarquez que cet événement ne fonctionne pas comme prévu dans le mode de jeu Jouer 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 le statut d'adhésion d'un joueur a changé. Notez, cependant, que le serveur ne tentera pas de vérifier et de mettre à jour le statut d'adhésion après que le modèle Premium soit fermé. Ainsi, pour tenir compte des cas où l'utilisateur achète Prem

Pour en savoir plus sur et incorporer Premium dans votre expérience et monétiser avec le système de paiement basé sur l'engagement, voir Engagement-Based Payouts .

Voir aussi :

• MarketplaceService:PromptPremiumPurchase() , utilisé pour inviter un utilisateur à acheter Premium
• MarketplaceService.PromptPremiumPurchaseFinished , se déclenche lorsque l'interface d'achat Premium est fermée

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 qu'un ChildRemoved ne le fasse sur Players et se

Ceci peut être utilisé avec 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 voulez suivre quand un personnage de 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 que de vérifier et de mettre à jour le statut après que la demande d'abonnement soit fermée. Pour tenir compte des cas dans lesquels l'utilisateur achète l'abonnement <

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

Paramètres