Players

Abilita o disabilita i seguenti metodi Players ( BanAsync() , UnbanAsync() e 2>Class.Players:GetBanHistoryAsync()|GetBanHistoryAsync()2> ) che costituiscono l'API di ban. Questa proprietà non è scriptabile e può essere

La proprietà BubbleChat indica se o no la chat a bolle è abilitata. È impostata con il metodo Players:SetChatStyle() utilizzando il gruppo Enum.ChatStyle .

Quando questa modalità di chat è abilitata, il gioco mostra le chat nell'interfaccia utente di chat nella parte superiore dello schermo.

Ci sono due altri modi di chat, Players.ClassicChat e un modello di chat in cui sono abilitati sia la chat classica che la chat a bolle.

La proprietà CharacterAutoLoads indica se Class.Character|Characters si rigenererà automaticamente. Il valore predefinito è vero.

Se questa proprietà è disabilitata (false), il giocatore Class.Character|Characters non si genererà fino a quando la funzione Player:LoadCharacter() non sarà chiamata per ogni Player, tra cui quando i giocatori si uniscono all'esperienza.

Questo può essere utile in esperienze in cui i giocatori hanno vitefinite, come giochi competitivi in cui i giocatori non respawnano fino a quando una partita non finisce.

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 no la chat classica è abilitata. Questa proprietà è impostata dal metodo Players:SetChatStyle() utilizzando l'еньucolo Enum.ChatStyle .

Quando questa modalità di chat è abilitata, il gioco mostra le chat in una bolle sopra la testa dell' mittente.

Ci sono due altri modi di chat, Players.BubbleChat e un modo di chat in cui sia chat classico che chat a bolle sono abilitati.

LocalPlayer è una proprietà di lettura che si riferisce al Player il cui client è in esecuzione l'esperienza.

Questa proprietà è definita solo per LocalScripts e ModuleScripts richiesti da loro, poiché vengono eseguiti sul client. Per il Server, su cui vengono eseguiti tutti gli oggetti Script, questa proprietà è 1> nil1> .

La proprietà MaxPlayers determinare il numero massimo di giocatori che possono essere in un Server. Questa proprietà può essere impostata solo attraverso le impostazioni di un Postospecifico sulla Dashboard del Creatore o attraverso le Impostazioni di gioco.

La proprietà PreferredPlayers indica il numero di giocatori a cui il matchmaker di Roblox riempirà i server. Questo numero sarà inferiore al numero massimo di giocatori ( Players.MaxPlayers ) supportati dall'esperienza.

La proprietà RespawnTime controlla il tempo, in secondi, ci vuole per un giocatore per respawn quando Players.CharacterAutoLoads è vero. Si predefinisce su 5.0 secondi.

Questo è utile quando vuoi cambiare il tempo di respawn in base al tipo di esperienza ma non vuoi gestire il respawn dei giocatori individualmente.

Although this property can be set from within a Script , you can more easily set it directly on the Players object in Studio's Explorer window.

Questa funzione fa in modo che il giocatore locale chatti il Messaggiofornito. Poiché questo oggetto è protetto, l'uso tentativo di utilizzarlo in un Script o LocalScript causerà un errore.

Invece, quando crei un sistema di chat personalizzato, o un sistema che ha bisogno di accesso alla chat, puoi utilizzare la funzione Chat della funzione Chat:Chat() invece.

Parametri

Restituzioni

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

Questa funzione cerca ogni player in Players per uno che corrisponde all'Player.UserId dato. Se tale giocatore non esiste, semplicemente restituisce 1> nil1> . È equivalente alla seguente funzione:

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

Questo metodo è utile per trovare il acquirente di un prodotto di sviluppatore usando MarketplaceService.ProcessReceipt , che fornisce una tabella che include l'ID dell'acquirente e non un riferimento all'oggetto Player . La maggior parte dei giochi richiederà un riferimento al giocatore in modo da poter concedere i prodotti.

Parametri

Restituzioni

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

Questa funzione restituisce il Player associato al Player.Character o nil se uno non può essere trovato. È equivalente alla seguente funzione:

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

Questo metodo viene spesso utilizzato quando si verifica un evento nel personaggio del Giocatore(come il loro Class.Humanoid``Class.Humanoid.Died|dying ). Tale evento potrebbe non fare riferimento diretto all'oggetto Player, ma questo metodo fornisce un facile Accesso. L'inverso di questo funzione può essere descritti come ottenere il personaggio di un giocatore. Per farlo, semplicemente accedere alla

Parametri

Restituzioni

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

Questo metodo restituisce una tabella di tutti gli oggetti Player attualmente connessi. Funziona allo stesso modo Instance:GetChildren() che eccezionalmente restituisce solo oggetti Player trovati sotto 1> Class.Players1> . Quando viene utilizzato con un ciclo 4> for

local Players = game:GetService("Players")

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

Gli script che si connettono a Players.PlayerAdded di solito cercano di elaborare ogni giocatore che si connette al Gioco. Questo metodo è utile per l'iterazione sui giocatori già connessi che non avrebbero mai fatto fuoco PlayerAdded . Utilizzando questo metodo, assicurati che nessun giocatore venga perso!

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)

Restituzioni

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)

Questa funzione imposta se BubbleChat e ClassicChat sono in uso, e dice a TeamChat e Chat cosa fare usando l'Enum.ChatStyle enumerazione. Poiché questo oggetto è protetto, l'uso tentativo di utilizzarlo in un Script o LocalScript causerà un errore.

Questa funzione viene utilizzata internamente quando la modalità chat è impostata dal Gioco.

Parametri

Restituzioni

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

Questa funzione fa in modo che il Players.LocalPlayer chat il Messaggiofornito, che sarà visibile solo dagli utenti nella stessa team. Poiché questo oggetto è protetto, l'uso di esso in un Script o LocalScript causerà un errore.

Questa funzione viene utilizzata internamente quando il Players.LocalPlayer invia un messaggio al loro team.

Parametri

Restituzioni

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

Il metodo Players:BanAsync() ti consente di bannare facilmente gli utenti che violano le linee guida della tua esperienza. Puoi specificare la durata della bann, abilitare la bann per propagarsi su account sospetti e fornire un messaggio all'utente bannato in conformità con le linee gu

Banning e Messaging

Gli utenti bannati verranno immediatamente evinti e prevenuti dal rientrare nelle tue esperienze. Verrà mostrato un messaggio di errore mostrando il tempo rimasto sul loro ban e il tuo DisplayReason . I sistemi di back-end di Roblox possono Filtroi giocatori su tutti i server che specifici. DisplayReason può avere

Luoghi e Universo

Per impostazione predefinita, i divieti si estendono in qualsiasi luogo all'interno di quel mondo. Per limitare il divieto all'unico luogo in cui viene chiamata questa API, configura ApplyToUniverse per false . Tuttavia, se un utente è stato bannato nel luogo di partenza dell'universo, esso effettivamente risulta nell'utente essere escluso dall'interezza dell'univer

Conti alternativi

Gli utenti giocano spesso sotto più account diversi, conosciuti come account alternativi o account alt, che a volte vengono utilizzati per bypassare i divieti di account. Per aiutarti a tenere gli utenti fuori, il comportamento predefinito di questa API diffonderà tutti i divieti dall'account di origine che hai vietato in qualsiasi dei loro presunti account alternativi. Puoi disabilitare le estensioni dei divieti per gli alt account configurando

Durata della Ban

Non tutte le violazioni sono uguali, quindi non tutte le sospension

Errori e Throttling

Questo metodo invoca un HTTP call to backend services che sono soggetti a throttling e potrebbero fallire. Se stai chiamando questo API con più di un UserId , questo metodo cercherà di eseguire la chiamata HTTP per ciascun ID. Quindi aggregerà eventuali messaggi di errore e li unirà come elenco separ

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

Il messaggio includerà sempre failure for UserId {} se è un errore HTTP.

Requisiti lato client

A causa dei rischi associati all'esclusione degli utenti, questo metodo può essere chiamato solo sul server di esperienza di backend (le chiamate client-side risulteranno in un errore). Puoi testare questa API in Studio, durante la Creazionicollaborativa , o in un team test, ma i divieti non si appliceranno alla produzione.

Questa API utilizza il User Restrictions Open Cloud API . Potrai utilizzare queste API per gestire i tuoi divieti in applicazioni di terze parti.

Parametri

Restituzioni

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

Restituisce un modello di personaggio equipaggiato con tutto ciò specificato nella descrizione umanoide, e è R6 o R15 come specificato dal tipo di attrezzatura.

Parametri

Restituzioni

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

Restituisce un set di modelli di personaggio con tutto l'equipaggiamento richiesto per corrispondere all'avatar dell'utente specificato dall'ID. Ciò include se quel personaggio è attualmente R6 o R15.

Parametri

Restituzioni

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

Recupera la cronologia di ban e unban di qualsiasi utente all'interno dell'universo dell'esperienza. Questo metodo restituisce un'istanza BanHistoryPages che eredita da Pages . Questa proprietà è abilitata e disabilitata dalla proprietà Players.BanningEnabled, che puoi attivare in Studio.

Questa chiamata di funzione avrà successo solo nei server di gioco di produzione e non sui dispositivi client o in Studio.

Questa API utilizza il User Restrictions Open Cloud API . Potrai utilizzare queste API per gestire i tuoi divieti in applicazioni di terze parti.

Parametri

Restituzioni

Questa funzione restituisce informazioni sull'Avatardi un Giocatore(ignorando gli oggetti) sul sito Web Roblox nella forma di un dizionario. Non va confuso con GetCharacterAppearanceAsync , che in realtà carica le risorse descritte da questo metodo. Puoi usare InsertService:LoadAsset() per caricare le

<tr>
  <td><code>risorse</code></td>
  <td>tabella (vedi sotto)</td>
  <td>Descrive le risorse equipaggiate (cappelli, parti del corpo, ecc.)</td>
</tr>

<tr>
  <td><code>colori del corpo</code></td>
  <td>tabella (vedi sotto)</td>
  <td>Descrive i valori BrickColor per ciascun limbo</td>
</tr>

<tr>
  <td><code>bodyColor3s</code></td>
  <td>tabella (vedi sotto)</td>
  <td>Descrive l'istanza Color3 per ciascun limbo che potrebbe non essere perfettamente corrispondente con bodyColors</td>
</tr>

<tr>
  <td><code>pantaloni di base applicati</code></td>
  <td>booleano</td>
  <td>Descrive se i pantaloni predefiniti sono applicati</td>
</tr>

<tr>
  <td><code>irtApplied predefinito</code></td>
  <td>booleano</td>
  <td>Descrive se la maglietta predefinita è applicata</td>
</tr>

<tr>
  <td><code>emotes</code></td>
  <td>tabella (vedi sotto)</td>
  <td>Descrive le animazioni emote equipaggiate</td>
</tr>

<tr>
  <td><code>playerAvatarType</code></td>
  <td>stringa</td>
  <td>O "R15" o "R6"</td>
</tr>

<tr>
  <td><code>scala</code></td>
  <td>tabella (vedi sotto)</td>
  <td>Descrive diversi fattori di ridimensionamento del corpo</td>
</tr>

Assets Sub-Table

La tabella assets è un'arrabbiata di tabelle che contengono le seguenti chiavi che descrivono le risorse attualmente equipaggiate dal Giocatore:

<tr>
  <td><code>id</code></td>
  <td>number</td>
  <td>L'ID risorsa dell'asset equipaggiato</td>
</tr>

<tr>
  <td><code>assetType</code></td>
  <td>tabella</td>
  <td>Una tabella con <code>nome</code> e <code>id</code> campi, ognuno dei quali descrive il tipo di risorsa equipaggiata ("Cappello", "Faccia", ecc.)</td>
</tr>

<tr>
  <td><code>nome</code></td>
  <td>stringa</td>
  <td>Il nome dell'risorsaequipaggiato</td>
</tr>

Scala sottotavola

La tabella scales ha le seguenti chiavi, ognuna delle quali corrisponde a una Humanoid Proprietàdi escaling: bodyType, 1> head1>, 4> height4>, 7> proportion7>, 9> depth9>, 0> wide</

Colori del corpo Sub-Table

La tabella bodyColors ha le seguenti chiavi, ognuna delle quali corrisponde a un BrickColor ID number che può essere utilizzato con Datatype.BrickColor.new(

Parametri

Restituzioni

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 funzione GetFriends Players restituisce un oggetto FriendPages che contiene informazioni su tutti gli amici del giocatore. Gli elementi all'interno dell'oggetto FriendPages sono tabelle con i seguenti campi:

<tr>
  <td>Identificatore</td>
  <td>int64</td>
  <td>L'ID utente dell'Amico/Amica</td>
</tr>

<tr>
  <td>Nome utente</td>
  <td>stringa</td>
  <td>Il Nome utentedell'Amico/Amica</td>
</tr>

<tr>
  <td>Nome visualizzato</td>
  <td>stringa</td>
  <td>Il <code>Class.Player.DisplayName|nome del display ]</code> del tuo Amico/Amica.</td>
</tr>

Vedi gli esempi di codice per un modo facile di itérare su tutti gli amici di un Giocatore.

Parametri

Restituzioni

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

Restituisce la DESCRIZIONE UMANA per un ID di abito specificato, che verrà impostato con le parti/colori/Animazioni ecc. Un abito può essere quello creato da un utente, o può essere l'abito per un pacchetto creato da Roblox.

Parametri

Restituzioni

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

Restituisce una HumanoidDescription che specifica tutto ciò che è equipaggiato per l'avatar dell'utente specificato dall'utente passato in UserId. Inclusa anche la scala e i colori del corpo.

Parametri

Restituzioni

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

La funzione GetNameFromUserIdAsync Players invierà una richiesta al sito Web Roblox chiedendo quale sia l'username dell'account con l'indirizzo UserId .

Questo metodo errori se non esiste un account con l'ID utente fornito. Se non sei sicuro che un account esistente con l'ID fornito esiste, è consigliato avvolgere le chiamate a questa funzione con pcall . Inoltre, puoi memorizzare manualmente i risultati per rendere future chiamate con lo stesso ID rapido. Vedi gli esempi di codice per saperne di più.

Parametri

Restituzioni

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"

Questa funzione invierà una richiesta al sito Web di Roblox chiedendo quale sia il Player.UserId dell'account con il nome Player dato.

Questo metodo errori se non esiste un account con l'Nome utentespecificato. Se non sei sicuro che tale account esiste, è consigliato avvolgere le chiamate a questa funzione con pcall . Inoltre, puoi memorizzare manualmente i risultati per velocizzare le future chiamate con lo stesso Nome utenteutente. Vedi gli esempi di codice per saperne di più.

Parametri

Restituzioni

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"

Questa funzione restituisce l'URL del contenuto di un'immagine dell'avatar di un Giocatoredato il loro UserId , la dimensione dell'immagine desiderata come Enum.ThumbnailSize 枚 e il tipo desiderato come Enum.ThumbnailType 枚. Ritorna anche un booleto che descrive se l'immagine è pronta all'uso.

La maggior parte delle volte, questo metodo viene utilizzato con ImageLabel.Image o Decal.Texture per mostrare le foto dell'avatar dell'utente in un'esperienza.

Parametri

Restituzioni

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)

Unbans i giocatori bannati da Players:BanAsync() o dalla User Restrictions Open Cloud API . Questo metodo è abilitato e disabilitato dalla ProprietàPlayers.BanningEnabled, che puoi attivare o disattivare in Studio.

Come Players:BanAsync() , questo metodo prende in un dizionario config che ti consente di eliminare utenti in attesa. Questo configura gli utenti che non sono in attesa e lo scopo da cui vengono eliminati.

L'unbans avrà effetto solo sui divieti con lo stesso ApplyToUniverse scopo. Ad esempio, un unbans con ApplyToUniverse impostato su true non invaliderà un precedente divieto con 2> ApplyToUniverse2> impostato su 5>

Questo metodo invoca un'API HTTP per i servizi di backend, che sono limitati e potrebbero fallire. Se stai chiamando questa API con più UserIds, questo metodo cercherà di eseguire questo richiamo HTTP

A causa dei rischi associati all'uso di utenti vietati, questo metodo può essere chiamato solo sul Serverdi gioco di backend. Le chiamate client-side risulteranno in un errore. Puoi testare questa API in Studio, Team Create e Team Test, ma i divieti non si appliceranno alla produzione. Questa chiamata di funzione chiamerà solo richieste di ban al server di produzione e non in Studio. Tuttavia, tutti i passaggi di input saranno ancora in Studio.

Questa API utilizza il User Restrictions Open Cloud API . Potrai utilizzare queste API per gestire i tuoi divieti in applicazioni di terze parti.

Parametri

<tbody>
  <tr>
    <td><code>UserIds</code></td>
    <td>vettore</td>
    <td>UserID per essere forzato nell'esperienza (s). La dimensione massima è <code>50</code> .</td>
  </tr>

  <tr>
    <td><code>Applica all'universo</code></td>
    <td>booleano</td>
    <td>Diffonde l'unban in tutti i luoghi all'interno di questo universo.</td>
  </tr>
</tbody>

Restituzioni

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'evento PlayerAdded viene attivato quando un giocatore entra nel Gioco. Questo viene utilizzato per attivare un evento quando un giocatore si unisce a un Gioco, come il caricamento dei dati salvati del GiocatoreGlobalDataStore.

Questo può essere utilizzato insieme all'evento Players.PlayerRemoving , che si attiva quando un giocatore è circa per lasciare il Gioco. Ad esempio, se si desidera stampare un messaggio ogni volta che un nuovo giocatore si unisce o lascia il Gioco:

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 vuoi tracciare quando un personaggio del Giocatoreviene aggiunto o rimosso dal Gioco, come quando un giocatore respawna o muore, puoi utilizzare le funzioni Player.CharacterAdded e Player.CharacterRemoving.

Nota che questo evento non funziona come previsto in Modalità Gioca poiché il giocatore viene creato prima che gli script che si connettono a PlayerAdded . Per gestire questo caso, nonché casi in cui lo script viene aggiunto nel gioco dopo l'ingresso di un giocatore, crea una funzione onPlayerAdded() che puoi chiamare per gestire l'ingresso di un Giocatore.

Parametri

local Players = game:GetService("Players")

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

Players.PlayerAdded:Connect(onPlayerAdded)

Questo evento si attiva quando il server di gioco riconosce che la membership di un Giocatoreè cambiata. Nota, tuttavia, che il server non cercherà di controllare e aggiornare la membership dopo che il Premium modal è stato chiuso. Quindi, per tenere conto dei casi in cui l'utente acquista Premium al di fuori del gioco

Per saperne di più su Premium e sull'incorporazione di Premium nella tua esperienza e sul monetizzazione con il sistema di pagamento basato sul coinvolgimento, vedi pagamenti basati sul coinvolgimento.

Vedi anche:

• MarketplaceService:PromptPremiumPurchase() , usato per richiedere a un utente di acquistare Premium
• MarketplaceService.PromptPremiumPurchaseFinished , si attiva quando l'interfaccia utente di acquisto premium si chiude

Parametri

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'evento PlayerRemoving si attiva proprio prima che un Player lasci il Gioco. Questo evento si attiva prima che ChildRemoved faccia su Players e si comporta in modo simile a <

Questo può essere utilizzato insieme all'evento Player.PlayerAdded, che si attiva quando un giocatore si unisce al Gioco. Ad esempio, per stampare un messaggio ogni volta che un nuovo giocatore si unisce o lascia il Gioco:

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 vuoi tracciare quando un personaggio del Giocatoreviene aggiunto o rimosso dal Gioco, come quando un giocatore respawna o muore, puoi utilizzare le funzioni Player.CharacterAdded e Player.CharacterRemoving.

Parametri

local Players = game:GetService("Players")

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

Players.PlayerRemoving:Connect(onPlayerRemoving)

Questo evento si attiva quando il server di gioco riconosce che lo stato dell'utente per una certa sottoscrizione è cambiato. Nota che il server non cerca e aggiorna lo stato dopo che la modalità di acquisto della sottoscrizione sia chiusa. Per tenere conto dei casi in cui l'utente acquista la sottoscrizione al di fu

Nota che solo gli script del server ricevono questo evento.

Parametri