Players

Ativa ou desativa os três métodos Players ( BanAsync() , UnbanAsync() e GetBanHistoryAsync() ) que constituem a API de banimento.Essa propriedade não é scriptável e só pode ser modificada no Studio.

Essa propriedade indica se o chat de bolhas está habilitado ou não. É definida com o método Players:SetChatStyle() usando o Enum.ChatStyle enum.

Quando este modo de chat é ativado, o jogo exibe chats na interface de usuário de chat no canto superior esquerdo da tela.

Existem dois outros modos de bate-papo, Players.ClassicChat e um modo de bate-papo onde tanto o bate-papo clássico quanto o bate-papo de bolhas são habilitados.

Essa propriedade indica se characters respawnará automaticamente. O valor padrão é verdadeiro.

Se esta propriedade estiver desativada (false), o jogador characters não será gerado até que a função Player:LoadCharacter() seja chamada para cada Player, incluindo quando os jogadores se juntam à experiência.

Isso pode ser útil em experiências em que os jogadores têm vidas finitas, como jogos competitivos em que os jogadores não reaparecem até que uma rodada do jogo termine.

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

Indica se o chat clássico está habilitado ou não. Essa propriedade é definida pelo método Players:SetChatStyle() usando o Enum.ChatStyle enum.

Quando este modo de chat é ativado, o jogo exibe chats em uma bolha acima da cabeça do remetente.

Existem dois outros modos de bate-papo, Players.BubbleChat e um modo de bate-papo onde tanto o bate-papo clássico quanto o bate-papo de bolhas são habilitados.

Essa propriedade de leitura exclusiva se refere à Player cujo cliente está executando a experiência.

Essa propriedade só é definida para LocalScripts e ModuleScripts necessárias por eles, pois elas são executadas no cliente.Para o servidor, no qual Script objetos executam seu código, esta propriedade é nil .

Essa propriedade determina o número máximo de jogadores que podem estar em um servidor.Essa propriedade só pode ser definida através das configurações de um local específico no Painel do Criador ou através das configurações de Jogos.

Essa propriedade indica o número de jogadores para os quais o matchmaker do Roblox preencherá os servidores.Este número será menor que o número máximo de jogadores ( Players.MaxPlayers ) suportados pela experiência.

Essa propriedade controla o tempo, em segundos, que leva para um jogador reaparecer quando Players.CharacterAutoLoads for verdadeiro. Padrão para 5.0 segundos.

Isso é útil quando você quer mudar o tempo que leva para reaparecer com base no tipo de sua experiência, mas não quer lidar com o spawning de jogadores individualmente.

Embora esta propriedade possa ser definida dentro de um , você pode definir mais facilmente diretamente no objeto em janela do Explorer do Studio.

Essa função faz o jogador local conversar a mensagem dada.Como este item está protegido, tentar usá-lo em um Script ou LocalScript causará um erro.

Em vez disso, ao criar um sistema de chat personalizado ou um sistema que precisa de acesso ao chat, você pode usar a função Chat do serviço Chat:Chat() em vez disso.

Parâmetros

Devolução

-- 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

Essa função pesquisa cada Player em Players por um que tenha Player.UserId correspondendo ao dado userId.Se tal jogador não existir, ele retorna nil .

Este método é útil para encontrar o comprador de um produto de desenvolvedor usando MarketplaceService.ProcessReceipt que fornece uma tabela que inclui o comprador de UserId e não uma referência ao próprio objeto Player.A maioria das experiências exigirá uma referência ao jogador para conceder produtos.

Parâmetros

Devolução

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

Essa função retorna o Player associado ao dado Player.Character ou nil se não puder ser encontrado.É equivalente à seguinte função:

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

Este método é frequentemente usado quando algum evento no personagem do jogador dispara (como seu Class.Humanoid``Class.Humanoid.Died|dying ).Tal evento pode não se referir diretamente ao ObjetoJogador, mas esse método fornece acesso fácil.O inverso dessa função pode ser descrito como obter o Personagem de um Jogador.Para fazer isso, simplesmente acesse a propriedade Personagem.

Parâmetros

Devolução

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

Este método retorna uma tabela de todos os objetos Player conectados atualmente.Ela funciona da mesma maneira que Instance:GetChildren() seria, exceto que só retorna Player objetos encontrados sob Players .Quando usado com um loop for , é útil para iterar sobre todos os jogadores em um jogo.

local Players = game:GetService("Players")

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

Scripts que se conectam a Players.PlayerAdded geralmente estão tentando processar todos os Jogadores que se conectam ao jogo.Este método é útil para iterar sobre jogadores já conectados que não disparariam PlayerAdded .Usar esse método garante que nenhum jogador seja perdido!

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)

Devolução

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)

Essa função define se o BubbleChat e o ClassicChat estão sendo usados e diz ao TeamChat e ao Chat o que fazer usando o enum Enum.ChatStyle.Como este item está protegido, tentar usá-lo em um Script ou LocalScript causará um erro.

Essa função é usada internamente quando o modo de bate-papo é definido pelo jogo.

Parâmetros

Devolução

-- 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

Essa função faz o Players.LocalPlayer chat da mensagem dada, que só será visível pelos usuários da mesma Equipe.Como este item está protegido, tentar usá-lo em um Script ou LocalScript causará um erro.

Essa função é usada internamente quando o Players.LocalPlayer envia uma mensagem para sua Equipe.

Parâmetros

Devolução

-- 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

O método Players:BanAsync() permite que você banir facilmente usuários que violam as diretrizes de sua experiência.Você pode especificar a duração do banimento, habilitar o banimento para se propagar para contas alternativas suspeitas e fornecer uma mensagem ao usuário banido de acordo com as Diretrizes de Uso.Você também deve postar as regras da sua experiência em algum lugar acessível a todos os usuários e fornecer uma maneira para eles atrair.Este método é ativado e desativado pela propriedade Players.BanningEnabled, que você pode ativar no Studio.

Proibição e Mensageria

Usuários banidos serão imediatamente expulsos e impedidos de se juntar às suas experiências.Eles serão apresentados com um modal de erro que exibe o tempo restante em seu banimento e seu DisplayReason .Os sistemas de backend do Roblox expulsarão os jogadores de todos os servidores a partir do(s) local(is) que você especificar.DisplayReason pode ter um comprimento máximo de 400 caracteres e está sujeito a um filtro de texto.Para mais informações sobre texto modal aceitável, veja mensagens de proibição.

Lugares e Universo

Por padrão, os banimentos se estendem a qualquer lugar dentro desse universo.Para limitar o banimento apenas ao local de onde esta API é chamada, configure ApplyToUniverse para false.No entanto, se um usuário for banido no local de início do universo, isso efetivamente resulta no usuário sendo excluído da totalidade do universo, independentemente de se uma proibição universal está em vigor ou não.

Contas Alternativas

Os usuários frequentemente jogam sob várias contas diferentes, conhecidas como contas alternativas ou contas alt, que às vezes são usadas para contornar os banimentos de contas.Para ajudá-lo a manter usuários banidos fora, o comportamento padrão desta API propagará todos os banimentos da conta de origem que você baniu para qualquer um de seus contas alternativas suspeitas.Você pode desativar as propagações de banimento para contas alternativas configurando ExcludeAltAccounts para true.

Duração do Banimento

Nem todas as transgressões são iguais, portanto, nem todas as proibições devem ter a mesma duração.Essa API permite que você configure a duração do banir, em segundos, com o campo Duration.Para especificar um banirpermanente, defina o campo para -1.Você também pode querer configurar dinamicamente a duração do banimento com base no histórico de banimento do usuário, que você pode consultar usando Players:GetBanHistoryAsync().Por exemplo, você pode querer considerar o número de banimentos, a duração de banimentos anteriores ou construir lógica a partir das notas que você salva sob PrivateReason , que podem ter até 1000 caracteres e não são filtradas por texto.PrivateReason notas nunca são compartilhadas com o cliente e podem ser consideradas seguras de atacantes.

Erros e Aceleração

Este método invoca uma chamada HTTP para serviços de back-end que estão sujeitos a aceleramento e podem falhar.Se você estiver chamando essa API com mais de um UserId, este método tentará fazer a chamada HTTP para cada ID.Então, agregará quaisquer mensagens de erro e as juntará como uma lista separada por vírgula.Por exemplo, se este método for invocado para cinco usuários e solicitações para aqueles com UserIds 2 e 4 falharem, a seguinte mensagem de erro aparece:

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

A mensagem sempre incluirá failure for UserId {} se for um erro HTTP.

Requisito do Lado do Cliente

Devido aos riscos associados ao banimento de usuários, este método só pode ser chamado no servidor de experiência de backend (chamadas do lado do cliente resultarão em um erro).Você pode testar essa API no Studio, durante colaborativa criações, ou em um teste em equipe, mas as proibições não se aplicarão à produção.

Essa API usa a Restrições de Usuário da API de Nuvem Aberta. Você poderá utilizar essas APIs para gerenciar suas proibições em aplicações de terceiros.

Parâmetros

Devolução

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

Retorna um modelo de personagem equipado com tudo o que está especificado na Descrição Humanoide passada e é R6 ou R15, conforme especificado pelo tipo de modelo.

Parâmetros

Devolução

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

Retorna um conjunto de configuração de modelo de personagem com tudo equipado para corresponder ao avatar do usuário especificado pelo ID passado.Isso inclui se esse personagem é atualmente R6 ou R15.

Parâmetros

Devolução

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

Recupera o histórico de banimento e desbanimento de qualquer usuário dentro do universo da experiência.Este método retorna uma instância BanHistoryPages que herda de Pages.Este método é ativado e desativado pela propriedade Players.BanningEnabled, que você pode ativar no Studio.

Essa chamada de função só terá sucesso em servidores de jogos de produção e não em dispositivos do cliente ou no Studio.

Essa API usa a Restrições de Usuário da API de Nuvem Aberta. Você poderá utilizar essas APIs para gerenciar suas proibições em aplicações de terceiros.

Parâmetros

Devolução

Essa função retorna informações sobre o avatar de um jogador (ignorando equipamento) no site do Roblox na forma de um dicionário.Não deve ser confundido com GetCharacterAppearanceAsync, que na verdade carrega os recursos descritos por este método.Você pode usar InsertService:LoadAsset() para carregar os recursos que são usados no avatar do jogador.A estrutura do dicionário retornado é a seguinte:

<th>Tipo</th>

    <th>Descrição</th>
  </tr>
</thead>

<tr>
  <td><code>ativos</code></td>

  <td>tabela (veja abaixo)</td>

  <td>Descreve os recursos equipados (chapéus, partes do corpo, etc)</td>
</tr>

<tr>
  <td><code>cores do corpo</code></td>

  <td>tabela (veja abaixo)</td>

  <td>Descreve os valores do BrickColor para cada membro</td>
</tr>

<tr>
  <td><code>corpoColor3s</code></td>

  <td>tabela (veja abaixo)</td>

  <td>Descreve a instância Color3 para cada membro que pode não combinar perfeitamente com as cores do corpo</td>
</tr>

<tr>
  <td><code>defaultPantsAplicado</code></td>

  <td>bool</td>

  <td>Descreve se as calças padrão são aplicadas</td>
</tr>

<tr>
  <td><code>defaultShirtApplied</code></td>

  <td>bool</td>

  <td>Descreve se a camisa padrão é aplicada</td>
</tr>

<tr>
  <td><code>emoções</code></td>

  <td>tabela (veja abaixo)</td>

  <td>Descreve as animações de emote equipadas</td>
</tr>

<tr>
  <td><code>tipo de avatar do jogador</code></td>

  <td>string / cadeia / texto</td>

  <td>Ou "R15" ou "R6"</td>
</tr>

<tr>
  <td><code>escamas</code></td>

  <td>tabela (veja abaixo)</td>

  <td>Descreve vários fatores de escalonamento de corpo</td>
</tr>

Subtabela de Recursos

A tabela assets é um array de tabelas que contém as seguintes chaves que descrevem os recursos atualmente equipados pelo jogador:

<th>Tipo</th>

    <th>Descrição</th>
  </tr>
</thead>

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

  <td>número</td>

  <td>O ID do recurso da ativo</td>
</tr>

<tr>
  <td><code>tipo de recurso</code></td>

  <td>tabela</td>

  <td>Uma tabela com os campos <code>nome</code> e <code>id</code>, cada um descrevendo o tipo de recurso equipado ("Chapéu", "Rosto", etc.)</td>
</tr>

<tr>
  <td><code>único nome</code></td>

  <td>string / cadeia / texto</td>

  <td>O nome do recurso ativo</td>
</tr>

Sub-Tabela de Balanças

A tabela scales tem as seguintes chaves, cada uma correspondendo a uma propriedade de escalonamento Humanoid : bodyType , head , height , proportion , depth , width .

Sub-Tabela de Cores do Corpo

A tabela bodyColors tem as seguintes chaves, cada uma correspondendo a um número que corresponde a um número de ID BrickColor que pode ser usado com BrickColor.new(id) : leftArmColorId , torsoColorId , rightArmColorId , headColorId , leftLegColorId , rightLegColorId .

Parâmetros

Devolução

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)

A função GetFriends Players retorna um objeto FriendPages que contém informações para todos os amigos do usuário dado.Os itens dentro do objeto FriendPages são tabelas com os seguintes campos:

<th>Tipo</th>

    <th>Descrição</th>
  </tr>
</thead>

<tr>
  <td>Id</td>

  <td>int64</td>

  <td>O ID do usuário do amizade</td>
</tr>

<tr>
  <td>Nome de usuário</td>

  <td>string / cadeia / texto</td>

  <td>O nome de usuário do amizade</td>
</tr>

<tr>
  <td>Nome de Exibição</td>

  <td>string / cadeia / texto</td>

  <td>O <code>Class.Player.DisplayName|display name</code> do amizade.</td>
</tr>

Veja os exemplos de código para uma maneira fácil de iterar sobre todos os amigos de um jogador.

Parâmetros

Devolução

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, ", "))

Retorna a Descrição Humanoide para um ID de roupas especificado, que será definido com as partes/cores/animações etc da roupa.Uma roupa pode ser criada por um usuário, ou pode ser a roupa para um conjunto criado pelo Roblox.

Parâmetros

Devolução

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

Retorna uma Descrição Humanoide que especifica tudo o que está equipado para o avatar do usuário especificado pelo ID passado.Também inclui escalas e cores do corpo.

Parâmetros

Devolução

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

A função GetNameFromUserIdAsync Players enviará uma consulta ao site do Roblox perguntando qual é o nome de usuário da conta com o dado UserId.

Este método erra se não existe uma conta com o ID de usuário dado.Se você não tem certeza de que tal conta existe, é recomendado envolver chamadas para essa função com pcall() .Além disso, você pode cachear manualmente os resultados para fazer chamadas futuras com o mesmo UserId rápido.Veja os exemplos de código para aprender mais.

Parâmetros

Devolução

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"

Essa função enviará uma consulta ao site do Roblox perguntando o que é o Player.UserId da conta com o nome dado Player.

Este método erra se não existir uma conta com o nome de usuário dado.Se você não tem certeza de que tal conta existe, é recomendado envolver chamadas para essa função com pcall() .Além disso, você pode cachear manualmente os resultados para fazer chamadas futuras rapidamente com o mesmo usuário.Veja os exemplos de código para aprender mais.

Parâmetros

Devolução

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"

Essa função retorna o URL do conteúdo de uma imagem do avatar de um jogador dado seu UserId , o tamanho de imagem desejado como um Enum.ThumbnailSize enum e o tipo desejado como um Enum.ThumbnailType enum.Ele também retorna um booleano que descreve se a imagem está pronta para uso.

Na maioria das vezes, este método é usado com ImageLabel.Image ou Decal.Texture para exibir imagens de avatar do usuário em uma experiência.

Parâmetros

Devolução

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)

Desbanir jogadores banidos de Players:BanAsync() ou da API de Nuvem Aberta de Restrições de Usuário.Este método é ativado e desativado pela propriedade Players.BanningEnabled, que você pode ativar no Studio.

Como Players:BanAsync() , este método recebe um dicionário config que permitirá que você desbanir em massa os usuários.Isso configura os usuários que estão desbanidos e o escopo de onde eles são desbanidos.

Desbans só terão efeito em bans com o mesmo escopo ApplyToUniverse.Por exemplo, um desbanimento com ApplyToUniverse definido para true não invalidará um banimento anterior com ApplyToUniverse definido para false.Em outras palavras, um desbanimento de nível do universo não invalidará um banirde nível do lugar.O oposto também é verdadeiro.

Este método invoca uma chamada HTTP para serviços de back-end, que são limitados e podem falhar.Se você estiver chamando esta API com vários UserIds, este método tentará fazer essa chamada HTTP para cada UserId.Então, agregará quaisquer mensagens de erro e as juntará como uma lista separada por vírgula.Por exemplo, se este método for invocado por cinco UserIds : {1, 2, 3, 4, 5} e solicitações para usuários 2 e 4 falharem, então aparece a seguinte mensagem de erro: HTTP failure for UserId 2: Timedout, HTTP 504 (Service unavailable) failure for UserId 4: Service exception. A mensagem sempre incluirá failure for UserId {} se for um erro HTTP.É um comportamento não definido se você passar em ambos os UserIds válidos e inválidos, ou sejaum UserId que não é um número positivo, pois algumas solicitações de rede podem ser bem-sucedidas antes que toda a entrada seja validada.

Devido aos riscos associados ao banimento de usuários, este método só pode ser chamado no servidor de jogo de back-end.Chamadas do lado do cliente resultarão em um erro.Você pode testar essa API no Studio, Criação em Equipe e Teste em Equipe, mas as proibições não se aplicarão à produção.Essa chamada de função só tentará solicitações de banimento em servidores de jogo de produção e não no teste do Studio.No entanto, todos os passos de validação de entrada ainda funcionarão no Studio.

Essa API usa a Restrições de Usuário da API de Nuvem Aberta. Você poderá utilizar essas APIs para gerenciar suas proibições em aplicações de terceiros.

Parâmetros

<th>Tipo</th>

    <th>Descrição</th>
  </tr>
</thead>

<tbody>
  <tr>
    <td><code>IDs de usuário</code></td>

    <td>matriz / lista</td>

    <td>IDs de usuário que devem ser forçados a entrar na experiência(s). O tamanho máximo é <code>50</code>.</td>
  </tr>

  <tr>
    <td><code>Aplicar ao Universo</code></td>

    <td>booleano</td>

    <td>Propaga o desbanimento para todos os lugares dentro deste universo.</td>
  </tr>
</tbody>

Devolução

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

Este evento dispara quando um jogador entra no jogo.Isso é usado para disparar um evento quando um jogador se junta a um jogo, como carregar os dados salvos do jogador GlobalDataStore.

Isso pode ser usado ao lado do evento Players.PlayerRemoving, que dispara quando um jogador está prestes a deixar o jogo.Por instância, se você gostaria de imprimir uma mensagem sempre que um novo jogador se junta ou deixa o jogo:

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)

Se você quiser rastrear quando o personagem de um jogador é adicionado ou removido do jogo, como quando um jogador respawna ou morre, você pode usar as funções Player.CharacterAdded e Player.CharacterRemoving.

Observe que este evento não funciona como esperado no modo Jogar porque o jogador é criado antes de scripts serem executados que se conectam a PlayerAdded.Para lidar com esse caso, bem como casos em que o script é adicionado ao jogo após um jogador entrar, crie uma função onPlayerAdded() que você possa chamar para lidar com a entrada de um jogador.

Parâmetros

local Players = game:GetService("Players")

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

Players.PlayerAdded:Connect(onPlayerAdded)

Este evento é disparado quando o servidor de jogos reconhece que a associação de um jogador mudou.Observe, no entanto, que o servidor só tentará verificar e atualizar a adesão depois que o modo Premium foi fechado.Assim, para contabilizar casos em que o usuário compra Premium fora do jogo enquanto joga, você ainda deve solicitar que eles comprem Premium; isso então mostrará uma mensagem dizendo que eles já foram aprimorados e, uma vez que eles fechem o modal, o servidor do jogo atualizará sua adesão e disparará esse evento.

Para aprender mais sobre e incorporar Premium em sua experiência e monetizar com o sistema de pagamentos baseado em engajamento, veja Pagamentos baseados em engajamento.

Veja também:

• MarketplaceService:PromptPremiumPurchase() , usado para solicitar que um usuário compre Premium
• MarketplaceService.PromptPremiumPurchaseFinished , dispara quando a interface de compra premium fecha

Parâmetros

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)

O evento Remoção de Jogador dispara imediatamente antes de um Player sair do jogo.Este evento dispara antes que ChildRemoved faça em Players, e se comporta de forma semelhante a Instance.DescendantRemoving.Uma vez que dispara antes da remoção real de um Player, este evento é útil para armazenar dados do jogador usando um GlobalDataStore.

Isso pode ser usado ao lado do evento Player.PlayerAdded, que dispara quando um jogador se junta ao jogo.Por instância, para imprimir uma mensagem sempre que um novo jogador se junta ou deixa o jogo:

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)

Se você quiser rastrear quando o personagem de um jogador é adicionado ou removido do jogo, como quando um jogador respawna ou morre, você pode usar as funções Player.CharacterAdded e Player.CharacterRemoving.

Parâmetros

local Players = game:GetService("Players")

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

Players.PlayerRemoving:Connect(onPlayerRemoving)

Este evento é disparado quando o servidor do jogo reconhece que o status do usuário para uma determinada assinatura mudou.Observe que o servidor apenas tenta verificar e atualizar o status depois que o modo de Compra de Subscrição foi fechado.Para contabilizar casos em que o usuário compra a assinatura fora do jogo enquanto joga, você ainda deve solicitar que ele compre a assinatura; o prompt mostra uma mensagem dizendo ao usuário que ele já está inscrito e, após fechar o modal, o servidor do jogo atualiza o status da assinatura e gera esse evento.

Observe que apenas scripts de servidor recebem esse evento.

Parâmetros