Players
*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.
Le service Players contient Player des objets pour les clients actuellement connectés à un serveur Roblox.Il contient également des informations sur la configuration d'un emplacement.Il peut récupérer des informations sur les joueurs non connectés au serveur, telles que les apparences de personnages, les amis et les miniatures d'avatar.
Résumé
Propriétés
Active ou désactive les trois méthodes Players ( BanAsync(), UnbanAsync(), et GetBanHistoryAsync() ) qui composent l'API de bannissement.Cette propriété n'est pas scriptable et ne peut être modifiée qu'en studio.
Indique si le chat à bulles est activé ou non. Il est défini avec la méthode Players:SetChatStyle().
Indique si characters réapparaîtra automatiquement.
Indique si le chat classique est activé ou non ; défini par la méthode Players:SetChatStyle().
Le Player pour lequel le LocalScript est en cours d'exécution.
Le nombre maximum de joueurs qui peuvent être sur un serveur.
Le nombre préféré de joueurs pour un serveur.
Contrôle le temps nécessaire pour que le personnage d'un joueur réapparaisse.
Méthodes
Fait que le joueur local discute le message donné.
Retourne le Player dont le Player.Character correspond à l'instance donnée, ou nil si on ne peut en trouver aucun.
Renvoie une table de tous les objets connectés actuellement Player objets.
Définit si BubbleChat et ClassicChat sont utilisés et indique à TeamChat et Chat quoi faire.
Fait du joueur local le chat du message donné, qui ne sera visible que par les utilisateurs de la même équipe.
Bannir les utilisateurs de votre expérience, avec des options pour spécifier la durée, la raison, si la ban s'applique à l'univers entier ou seulement à l'emplacementactuel, et plus encore.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
- CreateHumanoidModelFromDescription(description : HumanoidDescription,rigType : Enum.HumanoidRigType,assetTypeVerification : Enum.AssetTypeVerification):Model
Retourne un modèle de caractère équipé de tout ce qui est spécifié dans la description Humanoïde passée, et est R6 ou R15 comme spécifié par le type de rig.
Retourne un ensemble de configuration de modèle de caractère avec tout ce qui est équipé pour correspondre à l'avatar de l'utilisateur spécifié par l'ID renvoyé.
Récupère l'historique des bans et des débans de tout utilisateur dans l'univers de l'expérience.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
Renvoie des informations sur l'apparence du personnage d'un utilisateur donné.
Renvoie un objet FriendPages qui contient des informations pour tous les amis du joueur donné.
Retourne la description humanoïde pour une tenue spécifiée, qui sera définie avec les parties/couleurs/animations etc de la tenue.
Renvoie une description humanoïde qui spécifie tout ce qui est équipé pour l'avatar de l'utilisateur spécifié par l'ID renvoyé.
Envoyez une requête au site Web Roblox pour le nom d'utilisateur d'un compte avec un mot de passe donné UserId.
Envoyez une requête au site Web Roblox pour le userId d'un compte avec un nom d'utilisateur donné.
- GetUserThumbnailAsync(userId : number,thumbnailType : Enum.ThumbnailType,thumbnailSize : Enum.ThumbnailSize):Tuple
Renvoie l'URL du contenu d'une vignette de joueur donnée la taille et le taper, ainsi qu'un booléen décrivant si l'image est prête à l'utilisation.
Débannir les joueurs bannis de Players:BanAsync() ou de l'API de nuage d'interdictions d'utilisateur.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
Évènements
Se déclenche lorsqu'un joueur entre dans le jeu.
Se déclenche lorsque le serveur de jeu reconnaît que l'adhésion d'un joueur a changé.
Se déclenche lorsqu'un joueur est sur le point de quitter le jeu.
S'enflamme lorsque le serveur de jeu reconnaît que le statut de l'utilisateur pour un certain abonnement a changé.
Propriétés
BanningEnabled
Active ou désactive les trois méthodes Players ( BanAsync(), UnbanAsync(), et GetBanHistoryAsync() ) qui composent l'API de bannissement.Cette propriété n'est pas scriptable et ne peut être modifiée qu'en studio.
BubbleChat
Cette propriété indique si le chat à bulles est activé ou non. Elle est définie avec la méthode Players:SetChatStyle() en utilisant l'enumérateur Enum.ChatStyle.
Lorsque ce mode de chat est activé, le jeu affiche les conversations dans l'interface utilisateur de chat dans le coin supérieur gauche de l'écran.
Il existe deux autres modes de chat, Players.ClassicChat et un mode de chat où les deux chat classique et bulle sont activés.
CharacterAutoLoads
Cette propriété indique si characters réapparaîtra automatiquement. La valeur par défaut est vraie.
Si cette propriété est désactivée (fausse), le joueur characters ne sera pas généré jusqu'à ce que la fonction Player:LoadCharacter() soit appelée pour chaque Player, y compris lorsque les joueurs rejoignent l'expérience.
Cela peut être utile dans des expériences où les joueurs ont des vies finies, comme des jeux compétitifs dans lesquels les joueurs ne réapparaissent pas jusqu'à la fin d'une manche de jeu.
Échantillons de code
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
ClassicChat
Indique si le chat classique est activé ou non. Cette propriété est définie par la méthode Players:SetChatStyle() en utilisant l'enuméro Enum.ChatStyle.
Lorsque ce mode de chat est activé, le jeu affiche les conversations dans une bulle au-dessus de la tête de l'expéditeur.
Il existe deux autres modes de chat, Players.BubbleChat et un mode de chat où les deux chat classique et bulle sont activés.
LocalPlayer
Cette propriété de lecture se réfère à la Player dont le client exécute l'expérience.
Cette propriété n'est définie que pour LocalScripts et ModuleScripts requises par eux, puisqu'ils s'exécutent sur le client.Pour le serveur, sur lequel Script les objets exécutent leur code, cette propriété est nil .
MaxPlayers
Cette propriété détermine le nombre maximum de joueurs pouvant être sur un serveur.Cette propriété ne peut être définie que par les paramètres d'un emplacementspécifique sur le tableau de bord du créateur ou par les paramètres du jeu .
PreferredPlayers
Cette propriété indique le nombre de joueurs auxquels le matchmaker de Roblox remplira les serveurs.Ce nombre sera inférieur au nombre maximum de joueurs ( Players.MaxPlayers ) pris en charge par l'expérience.
RespawnTime
Cette propriété contrôle le temps, en secondes, qu'il faut pour qu'un joueur réapparaisse lorsque Players.CharacterAutoLoads est vrai. Elle est définie par défaut sur 5.0 secondes.
Cela est utile lorsque vous voulez changer la durée nécessaire pour réapparaître en fonction du type de votre expérience, mais que vous ne voulez pas gérer l'apparition des joueurs individuellement.
Bien que cette propriété puisse être définie à l'intérieur d'un Script , vous pouvez plus facilement la définir directement sur l'objet Players dans la fenêtre Explorateur de Studio.
UseStrafingAnimations
Méthodes
Chat
Cette fonction fait que le joueur local discute le message donné.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.
Au lieu de cela, lors de la création d'un système de chat personnalisé, ou d'un système qui a besoin d'accès au chat, vous pouvez utiliser la fonction Chat du service Chat:Chat() au lieu de cela.
Paramètres
Le message a discuté.
Retours
Échantillons de code
-- 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
GetPlayerByUserId
Cette fonction recherche chaque Player dans Players pour une dont le Player.UserId correspond au donné userId .Si un tel joueur n'existe pas, il renvoie nil .
Cette méthode est utile pour trouver l'acheteur d'un produit développeur en utilisant MarketplaceService.ProcessReceipt qui fournit une table incluant l'acheteur de UserId et non une référence à l'objet Player lui-même.La plupart des expériences nécessiteront une référence au joueur afin d'accorder des produits.
Paramètres
Le Player.UserId du joueur qui est spécifié.
Retours
Échantillons de code
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
GetPlayerFromCharacter
Cette fonction renvoie le Player associé au donné Player.Character ou nil si on ne peut pas en trouver.Il est équivalent à la fonction suivante :
local function getPlayerFromCharacter(character)
for _, player in game:GetService("Players"):GetPlayers() do
if player.Character == character then
return player
end
end
end
Cette méthode est souvent utilisée lorsque quelque événement dans le personnage du joueur se déclenche (comme leur Class.Humanoid``Class.Humanoid.Died|dying ).Un tel événement pourrait ne pas faire référence directement à l'objet Joueur, mais cette méthode fournit un accès facile.L'inverse de cette fonction peut être décrite comme obtenir le personnage d'un joueur.Pour ce faire, accédez simplement à la propriété Personnage.
Paramètres
Une instance de personnage que vous voulez obtenir le joueur.
Retours
Échantillons de code
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
GetPlayers
Cette méthode renvoie une table de tous les objets Player actuellement connectés.Il fonctionne de la même manière que Instance:GetChildren() sauf qu'il ne retourne que des objets Player trouvés sous Players .Lorsqu'il est utilisé avec une boucle for, il est utile pour itérer sur tous les joueurs dans un jeu.
local Players = game:GetService("Players")for _, player in Players:GetPlayers() doprint(player.Name)end
Les scripts qui se connectent à Players.PlayerAdded essaient souvent de traiter chaque joueur qui se connecte au jeu.Cette méthode est utile pour itérer sur les joueurs déjà connectés qui ne tireraient pas PlayerAdded .L'utilisation de cette méthode garantit que aucun joueur ne soit manqué !
local Players = game:GetService("Players")
local function onPlayerAdded(player)
print("Player: " .. player.Name)
end
for _, player in Players:GetPlayers() do
onPlayerAdded(player)
end
Players.PlayerAdded:Connect(onPlayerAdded)
Retours
Une table contenant tous les joueurs du serveur.
Échantillons de code
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)
SetChatStyle
Cette fonction détermine si BubbleChat et ClassicChat sont utilisés et indique à TeamChat et Chat quoi faire en utilisant l'enumérit Enum.ChatStyle.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.
Cette fonction est utilisée internement lorsque le mode de chat est défini par le jeu.
Paramètres
Le style de chat spécifié est configurer.
Retours
Échantillons de code
-- 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
TeamChat
Cette fonction fait du chat Players.LocalPlayer le message donné, qui ne sera visible que par les utilisateurs de la même équipe.Puisque cet élément est protégé, essayer de l'utiliser dans un Script ou LocalScript provoquera une erreur.
Cette fonction est utilisée internement lorsque le Players.LocalPlayer envoie un message à leur équipe.
Paramètres
Le message est discuté.
Retours
Échantillons de code
-- 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
BanAsync
La méthode Players:BanAsync() vous permet de bannir facilement les utilisateurs qui enfreignent les directives de votre expérience.Vous pouvez spécifier la durée de l'interdiction, activer l'interdiction pour se propager à des comptes alternatifs suspectés et fournir un message à l'utilisateur interdit en conformité avec les lignes directrices d'utilisation.Vous devez également publier vos règles d'expérience quelque part accessible à tous les utilisateurs et fournir un moyen pour eux d'Faire appel.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
Interdiction et messagerie
Les utilisateurs bannis seront immédiatement expulsés et empêchés de rejoindre vos expériences.Ils seront présentés avec une erreur affichant le temps restant sur leur interdiction et votre DisplayReason .Les systèmes arrière-plan de Roblox expulseront les joueurs sur tous les serveurs à partir des emplacementque vous spécifiez.DisplayReason peut avoir une longueur maximale de 400 caractères et est soumis à un filtresde texte.Pour plus d'informations sur le texte modal acceptable, voir messagerie de bannissement.
Lieux et univers
Par défaut, les interdictions s'étendent à tout endroit dans cet univers.Pour limiter la ban à seulement le lieu d'où cette API est appelée, configurez ApplyToUniverse à false .Cependant, si un utilisateur est banni au lieu de départ de l'univers, cela entraîne effectivement l'exclusion de l'utilisateur de l'ensemble de l'univers, indépendamment du fait qu'une interdiction universelle soit en place ou non.
Comptes alternatifs
Les utilisateurs jouent souvent sous plusieurs comptes différents, appelés comptes alternatifs ou comptes alt, qui sont parfois utilisés pour contourner les interdictions de compte.Pour vous aider à garder les utilisateurs interdits à l'écart, le comportement par défaut de cette API propagera toutes les interdictions de l'ensemble du compte source que vous avez interdit à l'un de leurs comptes alternatifs suspectés.Vous pouvez désactiver les propagations de bannissement aux comptes alternatifs en configurant ExcludeAltAccounts à true .
Durée du bannissement
Toutes les transgressions ne sont pas identiques, donc tous les bans ne devraient pas être de la même longueur.Cette API vous permet de configurer la durée de l'bannir, en secondes, avec le champ Duration.Pour spécifier un bannirpermanent, définissez le champ à -1 .Vous pouvez également vouloir configurer dynamiquement la durée de l'interdiction en fonction de l'historique des interdictions de l'utilisateur, que vous pouvez interroger en utilisant Players:GetBanHistoryAsync() .Par exemple, vous pouvez vouloir envisager le nombre de bans, la durée des bans précédentes, ou construire la logique à partir des notes que vous enregistrez sous PrivateReason qui peuvent comporter jusqu'à 1000 caractères et ne sont pas filtrées par le texte.PrivateReason les notes ne sont jamais partagées avec le client et peuvent être considérées comme sûres des attaquants.
Erreurs et ralentissement
Cette méthode lance un appel HTTP vers les services arrière-plan qui sont soumis à une restriction et peuvent échouer.Si vous appelez cette API avec plus d'une UserId, cette méthode tentera de faire l'appel HTTP pour chaque ID.Il agrégera ensuite tous les messages d'erreur et les joindra comme une liste séparée par une virgule.Par exemple, si cette méthode est invoquée pour cinq utilisateurs et que les demandes des utilisateurs avec UserIds 2 et 4 échouent, le message d'erreur suivant apparaît :
HTTP failure for UserId 2: Timedout, HTTP 504 (Service unavailable) failure for UserId 4: Service exception
Le message inclura toujours failure for UserId {} si c'est une erreur HTTP.
Exigence côté client
En raison des risques associés à l'interdiction des utilisateurs, cette méthode ne peut être appelée que sur le serveur d'expérience arrière-plan (les appels côté client entraîneront une erreur).Vous pouvez tester cette API dans Studio, pendant la créationscollaborative ou dans un test d'équipe, mais les interdictions ne s'appliqueront pas à la production.
Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.
Paramètres
UserIds (requis; matrice) — Array de UserIds de joueurs à bannir. Taille maximale est 50 .
ApplyToUniverse (facultatif; booléen) — Si la ban se propage à tous les endroits dans l'univers de l'expérience. La valeur par défaut est true .
Duration (requis ; entier) — Durée de l'bannir, en secondes.Les interdictions permanentes devraient avoir une valeur de -1 .0 et toutes les autres valeurs négatives sont nulles.
DisplayReason (requis; chaîne) — Le message qui sera affiché aux utilisateurs lorsqu'ils tentent de rejoindre et échouent à rejoindre une expérience.La longueur maximale de la chaîne est 400 .
PrivateReason (requis; chaîne) — Messagerie interne qui sera renvoyée lors de la recherche de l'historique des bans de l'utilisateur. La longueur maximale de la chaîne est 1000 .
ExcludeAltAccounts (facultatif; booléen) — Lorsque true, Roblox n'essaie pas d'interdire les comptes alt. La valeur par défaut est false .
Retours
Échantillons de code
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
CreateHumanoidModelFromDescription
Retourne un modèle de caractère équipé de tout ce qui est spécifié dans la description Humanoïde passée, et est R6 ou R15 comme spécifié par le type de rig.
Paramètres
Spécifie l'apparence du caractère retourné.
Spécifie si le caractère retourné sera R6 ou R15.
La vérification du type de ressource détermine si cette fonction chargera des modèles ou non (vous devez le définir toujours à moins que vous ne vouliez charger des ressources non cataloguées).
Retours
Un modèle de personnage humanoïde.
Échantillons de code
game.Players:CreateHumanoidModelFromDescription(Instance.new("HumanoidDescription"), Enum.HumanoidRigType.R15).Parent =
game.Workspace
CreateHumanoidModelFromUserId
Retourne un ensemble de configuration de modèle de caractère avec tout ce qui est équipé pour correspondre à l'avatar de l'utilisateur spécifié par l'ID renvoyé.Cela inclut si ce personnage est actuellement R6 ou R15.
Paramètres
L'ID d'utilisateur pour un utilisateur Roblox. (L'ID d'utilisateur est le nombre dans le profil de l'utilisateur par exemple www.roblox.com/users/1/profile).
Retours
Un modèle de personnage humanoïde.
Échantillons de code
game.Players:CreateHumanoidModelFromUserId(1).Parent = game.Workspace
GetBanHistoryAsync
Récupère l'historique des bans et des débans de tout utilisateur dans l'univers de l'expérience.Cette méthode renvoie une instance BanHistoryPages qui hérite de Pages.Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
Cet appel de fonction réussira seulement sur les serveurs de jeu en production et non sur les appareils clients ou dans Studio.
Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.
Paramètres
Retours
Voir BanHistoryPages pour la référence de retour.
GetCharacterAppearanceInfoAsync
Cette fonction renvoie des informations sur l'avatar d'un joueur (ignorant l'équipment) sur le site Web de Roblox sous la forme d'un dictionnaire.Il ne doit pas être confondu avec GetCharacterAppearanceAsync , qui charge réellement les ressources décrites par cette méthode.Vous pouvez utiliser InsertService:LoadAsset() pour charger les ressources utilisées dans l'avatar du joueur.La structure du dictionnaire retourné est la suivante :
<th>Type</th><th>Avertissement</th></tr></thead><tr><td><code>ressources</code></td><td>table (voir ci-dessous)</td><td>Décrit les ressources équipées (chapeaux, parties du corps, etc)</td></tr><tr><td><code>couleurs du corps</code></td><td>table (voir ci-dessous)</td><td>Définit les valeurs de couleur brique pour chaque membre</td></tr><tr><td><code>couleur du corps3s</code></td><td>table (voir ci-dessous)</td><td>Décrit l'instance Color3 pour chaque membre qui peut ne pas correspondre parfaitement aux couleurs du corps</td></tr><tr><td><code>pantalons par défaut appliqués</code></td><td>bool</td><td>Détermine si des pantalons par défaut sont appliqués</td></tr><tr><td><code>defaultShirtAppliqué</code></td><td>bool</td><td>Détermine si la chemise par défaut est appliquée</td></tr><tr><td><code>émotes</code></td><td>table (voir ci-dessous)</td><td>Décrit les animations d'émote équipées</td></tr><tr><td><code>type d'avatar du joueur</code></td><td>chaîne</td><td>Soit « R15 » ou « R6 »</td></tr><tr><td><code>écailles</code></td><td>table (voir ci-dessous)</td><td>Décrit divers facteurs d'ajustement du corps</td></tr>
Nom |
---|
Tableau des ressources sous-table
La table assets est un tableau d'associations de tables contenant les clés suivantes qui décrivent les ressources actuellement équipées par le joueur :
<th>Type</th><th>Avertissement</th></tr></thead><tr><td><code>id</code></td><td>numéro</td><td>L'ID de la ressource de la ressource équipée</td></tr><tr><td><code>type de ressource</code></td><td>tableau</td><td>Une table avec les champs <code>nom</code> et <code>ID</code>, chacun décrivant le type de ressource équipée ("Chapeau", "Visage", etc.)</td></tr><tr><td><code>nom</code></td><td>chaîne</td><td>Le nom de la contenu</td></tr>
Nom |
---|
Sous-tableau des échelles
La table scales a les clés suivantes, chacune correspondant à une propriété d'ajustement Humanoid : bodyType , head , height , proportion , depth , width .
Sous-tableau des couleurs du corps
La table bodyColors a les clés suivantes, chacune correspondant à un nombre correspondant à un numéro d'ID BrickColor qui peut être utilisé avec BrickColor.new(id) : leftArmColorId , torsoColorId , rightArmColorId , headColorId , leftLegColorId , rightLegColorId .
Paramètres
L'ID* de l'utilisateur du joueur spécifié.
Retours
Un dictionnaire contenant des informations sur l'apparence du personnage d'un utilisateur donné.
Échantillons de code
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)
GetFriendsAsync
La fonction GetFriends Players retourne un objet FriendPages qui contient des informations pour tous les amis de l'utilisateur donné.Les éléments de l'objet FriendPages sont des tables avec les champs suivants :
<th>Type</th><th>Avertissement</th></tr></thead><tr><td>Id</td><td>int64</td><td>L'ID utilisateur de l'ami</td></tr><tr><td>Nom d'utilisateur</td><td>chaîne</td><td>Le nom d'utilisateur de l'ami</td></tr><tr><td>Nom à afficher</td><td>chaîne</td><td>Le <code>Class.Player.DisplayName|nom d'affichage du ami</code> de l'ami.</td></tr>
Nom |
---|
Voir les échantillons de code pour une façon facile d'itérer sur tous les amis d'un joueur.
Paramètres
L'ID utilisateur du joueur qui est spécifié.
Retours
Échantillons de code
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, ", "))
GetHumanoidDescriptionFromOutfitId
Retourne la description humanoïde pour un ID de tenue spécifié, qui sera défini avec les parties/couleurs/animations etc. de la tenue.Une tenue peut être créée par un utilisateur, ou elle peut être la tenue pour un paquet créé par Roblox.
Paramètres
L'ID de la tenue pour laquelle la description humanoïde est recherchée.
Retours
Description humanoïde initialisée avec la spécification pour l'outfitId transmis.
Échantillons de code
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
GetHumanoidDescriptionFromUserId
Renvoie une description humanoïde qui spécifie tout ce qui est équipé pour l'avatar de l'utilisateur spécifié par l'ID renvoyé.Comprend également les écailles et les couleurs du corps.
Paramètres
L'ID d'utilisateur pour un utilisateur Roblox. (L'ID d'utilisateur est le nombre dans le profil de l'utilisateur par exemple www.roblox.com/users/1/profile).
Retours
Description humanoïde initialisée avec la spécification d'avatar du utilisateur passée.
Échantillons de code
game.Players:CreateHumanoidModelFromDescription(
game.Players:GetHumanoidDescriptionFromUserId(1),
Enum.HumanoidRigType.R15
).Parent =
game.Workspace
GetNameFromUserIdAsync
La fonction GetNameFromUserIdAsync Players enverra une requête au site Web Roblox pour demander quel est le nom d'utilisateur du compte avec le mot donné UserId.
Cette méthode échoue si aucun compte n'existe avec l'ID utilisateur donné.Si vous n'êtes pas sûr qu'un tel compte existe, il est recommandé d'envelopper les appels à cette fonction avec pcall() .En outre, vous pouvez cacher manuellement les résultats pour effectuer des appels futurs avec le même UserId rapidement.Voir les échantillons de code pour en savoir plus.
Paramètres
Le Player.UserId du joueur qui est spécifié.
Retours
Le nom d'un utilisateur avec le nom spécifié Player.UserId.
Échantillons de code
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"
GetUserIdFromNameAsync
Cette fonction enverra une requête au site Web Roblox pour demander ce que le Player.UserId est de l' compte avec le nom donné Player.
Cette méthode échoue si aucun compte n'existe avec le nom d'utilisateur donné.Si vous n'êtes pas sûr qu'un tel compte existe, il est recommandé d'envelopper les appels à cette fonction avec pcall() .En outre, vous pouvez cacher manuellement les résultats pour effectuer rapidement des appels futurs avec le même nom d'utilisateur.Voir les échantillons de code pour en savoir plus.
Paramètres
Le nom d'utilisateur du joueur qui est spécifié.
Retours
Le Player.UserId d'un utilisateur dont le nom est spécifié.
Échantillons de code
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"
GetUserThumbnailAsync
Cette fonction renvoie l'URL du contenu d'une image de l'avatar d'un joueur donnée leur UserId , la taille d'image souhaitée en tant qu'enumérateur Enum.ThumbnailSize , et le type souhaité en tant qu'enumérateur Enum.ThumbnailType.Il renvoie également un booléen décrivant si l'image est prête à l'utilisation.
La plupart du temps, cette méthode est utilisée avec ImageLabel.Image ou Decal.Texture pour afficher des images d'avatar d'utilisateur dans une expérience.
Paramètres
Le Player.UserId du joueur qui est spécifié.
A Enum.ThumbnailType décrivant le type de miniature.
Un Enum.ThumbnailSize précisant la taille de la miniature.
Retours
Un tuple contenant l'URL du contenu d'une vignette d'utilisateur en fonction des paramètres spécifiés, et un booléen décrivant si l'image est prête à être utilisée ou non.
Échantillons de code
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)
UnbanAsync
Débannir les joueurs bannis de ou de l'API de cloud ouvert des restrictions d'utilisateur .Cette méthode est activée et désactivée par la propriété Players.BanningEnabled, que vous pouvez activer dans Studio.
Comme Players:BanAsync(), cette méthode prend un dictionnaire config qui vous permettra de masser débannir les utilisateurs.Cela configure les utilisateurs qui sont débannés et la portée à partir de laquelle ils sont débannés.
Les débans n'auront d'effet que sur les interdictions ayant le même champ ApplyToUniverse .Par exemple, un débannissement avec ApplyToUniverse défini sur true ne rendra pas un précédent bannissement avec ApplyToUniverse défini sur false invalide.En d'autres termes, un déban au niveau de l'univers ne rendra pas un bannirau niveau d'un lieu invalide.L'inverse est également vrai.
Cette méthode lance un appel HTTP vers les services arrière-plan, qui sont limités et peuvent échouer.Si vous appelez cette API avec plusieurs UserIds, cette méthode tentera de faire cette requête HTTP pour chaque UserId.Il agrégera ensuite tous les messages d'erreur et les joindra comme une liste séparée par une virgule.Par exemple, si cette méthode est invoquée pour cinq UserIds : {1, 2, 3, 4, 5} et que les demandes pour les utilisateurs 2 et 4 échouent, le message d'erreur suivant apparaît : HTTP failure for UserId 2: Timedout, HTTP 504 (Service unavailable) failure for UserId 4: Service exception. Le message inclura toujours failure for UserId {} si c'est une erreur HTTP.C'est un comportement non défini si vous passez à la fois des UserIds valides et invalides, c'est-à-direun UserId qui n'est pas un nombre positif, car certaines demandes réseau peuvent réussir avant que toute entrée soit validée.
En raison des risques associés à l'interdiction des utilisateurs, cette méthode ne peut être appelée que sur le serveur de jeu arrière-plan.Les appels côté client entraîneront une erreur.Vous pouvez tester cette API dans Studio, création d'équipe et test d'équipe, mais les interdictions ne s'appliqueront pas à la production.Cet appel de fonction ne tentera que des demandes d'interdiction sur les serveurs de jeu en production et non dans le test de Studio.Cependant, toutes les étapes de validation d'entrée fonctionneront toujours dans Studio.
Cette API utilise la Restrictions d'utilisateur Open Cloud API. Vous serez en mesure d'utiliser ces API pour gérer vos interdictions dans des applications tierces.
Paramètres
<th>Type</th><th>Avertissement</th></tr></thead><tbody><tr><td><code>ID utilisateur</code></td><td>matrice</td><td>Les ID d'utilisateur doivent être forcés dans l'expérience(s). La taille maximale est de <code>50</code> .</td></tr><tr><td><code>Appliquer à l'univers</code></td><td>booléen</td><td>Propague le déban à tous les endroits dans cet univers.</td></tr></tbody>
Nom |
---|
Retours
Échantillons de code
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
Évènements
PlayerAdded
Cet événement se déclenche lorsqu'un joueur entre dans le jeu.Ceci est utilisé pour déclencher un événement lorsqu'un joueur rejoint un jeu, comme le chargement des données sauvegardées du joueur GlobalDataStore.
Cela peut être utilisé en même temps que l'événement Players.PlayerRemoving, qui se déclenche lorsqu'un joueur est sur le point de quitter le jeu.Par instance, si vous souhaitez imprimer un message chaque fois qu'un nouveau joueur rejoint ou quitte le jeu :
local Players = game:GetService("Players")
Players.PlayerAdded:Connect(function(player)
print(player.Name .. " joined the game!")
end)
Players.PlayerRemoving:Connect(function(player)
print(player.Name .. " left the game!")
end)
Si vous souhaitez suivre quand le personnage d'un joueur est ajouté ou supprimé du jeu, comme lorsqu'un joueur réapparaît ou meurt, vous pouvez utiliser les fonctions Player.CharacterAdded et Player.CharacterRemoving.
Notez que cet événement ne fonctionne pas comme prévu en mode lecture car le joueur est créé avant que les scripts se connectent à PlayerAdded.Pour gérer ce cas, ainsi que les cas dans lesquels le script est ajouté dans le jeu après l'entrée d'un joueur, créez une fonction onPlayerAdded() que vous pouvez appeler pour gérer l'entrée d'un joueur.
Paramètres
Une instance du joueur qui a rejoint le jeu.
Échantillons de code
local Players = game:GetService("Players")
local function onPlayerAdded(player)
print("A player has entered: " .. player.Name)
end
Players.PlayerAdded:Connect(onPlayerAdded)
PlayerMembershipChanged
Cet événement se déclenche lorsque le serveur de jeu reconnaît que l'adhésion d'un joueur a changé.Remarquez cependant que le serveur ne tentera de vérifier et de mettre à jour l'adhésion après que la modalité Premium a été fermée.Ainsi, pour tenir compte des cas où l'utilisateur achète Premium en dehors du jeu pendant qu'il joue, vous devez toujours les inciter à acheter Premium ; cela montrera ensuite un message leur indiquant qu'ils sont déjà améliorés et, une fois qu'ils ferment la modalité, le serveur de jeu mettra à jour leur adhésion et déclenchera cet événement.
Pour en savoir plus sur et intégrer Premium dans votre expérience et monétiser avec le système de paiements basé sur l'engagement, voir paiements basés sur l'engagement.
Voir aussi :
- MarketplaceService:PromptPremiumPurchase() , utilisé pour inciter un utilisateur à acheter Premium
- MarketplaceService.PromptPremiumPurchaseFinished , se déclenche lorsque l'interface utilisateur d'achat premium se ferme
Paramètres
Échantillons de code
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)
PlayerRemoving
L'événement PlayerRemoving se déclenche juste avant qu'un Player quitte le jeu.Cet événement se déclenche avant que ChildRemoved ne fasse sur Players , et se comporte de manière similaire à Instance.DescendantRemoving .Puisqu'il se déclenche avant l'élimination réelle d'un Player , cet événement est utile pour stocker les données du joueur en utilisant un GlobalDataStore .
Cela peut être utilisé en même temps que l'événement Player.PlayerAdded, qui se déclenche lorsqu'un joueur rejoint le jeu.Par instance, pour imprimer un message chaque fois qu'un nouveau joueur rejoint ou quitte le jeu :
local Players = game:GetService("Players")
Players.PlayerAdded:Connect(function(player)
print(player.Name .. " joined the game!")
end)
Players.PlayerRemoving:Connect(function(player)
print(player.Name .. " left the game!")
end)
Si vous souhaitez suivre quand le personnage d'un joueur est ajouté ou supprimé du jeu, comme lorsqu'un joueur réapparaît ou meurt, vous pouvez utiliser les fonctions Player.CharacterAdded et Player.CharacterRemoving.
Paramètres
Une instance du joueur qui quitte le jeu.
Échantillons de code
local Players = game:GetService("Players")
local function onPlayerRemoving(player)
print("A player has left: " .. player.Name)
end
Players.PlayerRemoving:Connect(onPlayerRemoving)
UserSubscriptionStatusChanged
Cet événement se déclenche lorsque le serveur de jeu reconnaît que le statut de l'utilisateur pour un certain abonnement a changé.Notez que le serveur ne tente de vérifier et de mettre à jour le statut qu'après que la modalité d'achat d'abonnement a été fermée.Pour tenir compte des cas dans lesquels l'utilisateur achète l'abonnement en dehors du jeu pendant qu'il joue, vous devez toujours les inciter à acheter l'abonnement ; la demande affiche un message indiquant à l'utilisateur qu'il est déjà abonné, et après qu'il ferme la modalité, le serveur de jeu met à jour son statut d'abonnement et déclenche cet événement.
Notez que seuls les scripts du serveur reçoivent cet événement.
Paramètres
Utilisateur dont le statut d'abonnement a changé.
L'ID de l'abonnement avec un changement de statut.