Użytkownicy i identyfikatory użytkowników w zakresie

Roblox udostępnia jeden skuteczny identyfikator użytkownika dla każdego użytkownika w każdej grze, grupie lub aplikacji. W zależności od historii użytkownika w danej domenie, jego skuteczny identyfikator użytkownika to albo jego globalny identyfikator użytkownika, albo identyfikator użytkownika w zakresie. Ta strona wyjaśnia, jak działają skuteczne identyfikatory użytkowników i jak używać typu User w kodzie gry.

Następujące pojęcia są kluczowe dla identyfikacji użytkowników:

Skuteczne identyfikatory użytkowników i domeny

Każdy użytkownik ma jeden skuteczny identyfikator użytkownika w konkretnej grze, grupie lub aplikacji. Roblox nie udostępnia oddzielnych globalnych i zakresowych identyfikatorów użytkowników dla tego samego użytkownika w danej domenie:

• Użytkownik przed wdrożeniem ma swój globalny identyfikator użytkownika jako skuteczny identyfikator użytkownika.
• Użytkownik po wdrożeniu ma identyfikator użytkownika w zakresie jako skuteczny identyfikator użytkownika. Ten identyfikator ma znaczenie tylko w tej domenie.

W kodzie gry, Player.UserId oraz Player.User.Id zwracają ten skuteczny identyfikator użytkownika i zawsze mają tę samą wartość numeryczną (Player.User.Id równa się Player.UserId), więc twój kod nie potrzebuje logiki rozgałęziającej, aby wybierać między nimi.

Roblox ogranicza tożsamość użytkownika do trzech typów domen:

Jak działają skuteczne identyfikatory użytkowników

Gdy gracz dołącza do twojej gry, ma jeden skuteczny identyfikator użytkownika dla tej gry. Skuteczny identyfikator użytkownika użytkownika po wdrożeniu to identyfikator użytkownika w zakresie unikalny dla tej gry. Otrzymuje inny identyfikator użytkownika w zakresie w każdej innej grze, grupie lub aplikacji, w której również jest użytkownikiem po wdrożeniu. Oznacza to:

• Skuteczne identyfikatory użytkowników są liczbami całkowitymi, niezależnie od tego, czy są globalne, czy w zakresie.
• Skuteczne identyfikatory użytkowników są stabilne w sesjach w tej samej domenie.
• Identyfikator użytkownika w zakresie nie koliduje z żadnym istniejącym globalnym identyfikatorem użytkownika.
• Ta sama wartość numeryczna może występować w różnych domenach dla różnych użytkowników. Unikalnym kluczem jest kombinacja domeny (typ domeny i identyfikator domeny) oraz skutecznego identyfikatora użytkownika.

Przykładowy scenariusz

Następujący przykład ilustruje, jak różne gry odnoszą się do tego samego użytkownika:

Użytkownicy przed wdrożeniem

Jeśli gracz jest użytkownikiem przed wdrożeniem w twojej grze, jego skuteczny identyfikator użytkownika pozostaje jego globalnym identyfikatorem użytkownika w tej grze. Zarówno Player.UserId, jak i Player.User.Id zwracają ten globalny identyfikator użytkownika. Roblox nie udostępnia drugiego identyfikatora użytkownika dla gracza w tej grze. Zapewnia to, że istniejące klucze w magazynie danych, tablice liderów i inwentarze działają nadal bez żadnych zmian.

Domena grupy

Każda grupa Roblox jest swoją własną domeną. Użytkownik ma jeden skuteczny identyfikator użytkownika w grupie, oddzielony od swojego skutecznego identyfikatora użytkownika w jakiejkolwiek grze lub aplikacji OAuth:

• Sprawdzanie grupy w grze nie zmienia się — Metody silnika na Player, takie jak Player:IsInGroupAsync(), Player:GetRankInGroupAsync() i Player:GetRoleInGroupAsync(), a także GroupService:PromptJoinAsync(), rozwiązują tożsamość wewnętrznie, nie ujawniając identyfikatora użytkownika.
• Otwarte API grupy w chmurze używają domeny grupy — Dotyczy to punktów końcowych, które listują lub zarządzają członkostwem w grupie i prośbami o dołączenie.

Praca z typem użytkownika

User jest standardowym sposobem identyfikacji użytkowników w kodzie gry. Wartość User zawiera skuteczny identyfikator użytkownika wraz z typem domeny i identyfikatorem domeny, więc kontekst tożsamości zawsze podróżuje z identyfikatorem. Aby uzyskać pełne szczegóły API, zobacz dokumentację User.

Uzyskiwanie użytkownika z gracza

Podstawowym sposobem uzyskania User jest połączenie z Player za pomocą Player.User:

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
    local user = player.User
    print("Skuteczny identyfikator użytkownika:", user.Id) -- Zawsze odpowiada player.UserId
    print("Typ domeny:", user.DomainType)
    print("Identyfikator domeny:", user.DomainId)
end)

Tworzenie użytkownika z identyfikatora

Aby utworzyć User z znanego skutecznego identyfikatora użytkownika w bieżącej grze, użyj User.fromId():

local user = User.fromId(knownUserId)

Używanie użytkownika z API silnika

API silnika, które akceptują parametr identyfikatora użytkownika, akceptują również wartości User bezpośrednio. Zaleca się używanie User:

-- Obie formy działają:
BadgeService:AwardBadge(player.User, badgeId)    -- Zalecane
BadgeService:AwardBadge(player.UserId, badgeId)

-- Obie formy działają:
local target = Players:GetPlayerByUserId(player.User) -- Zalecane
local target = Players:GetPlayerByUserId(someUserId)

Gdy numeryczny identyfikator użytkownika jest przekazywany do API silnika, które akceptuje identyfikatory użytkowników, jest automatycznie opakowywany w User wewnętrznie.

API silnika, które zwracają identyfikatory użytkowników

API silnika, które zwracają numeryczne identyfikatory użytkowników, zwracają skuteczny identyfikator użytkownika:

• Użytkownicy przed wdrożeniem — API zwraca globalny identyfikator użytkownika.
• Użytkownicy po wdrożeniu — API zwraca identyfikator użytkownika w zakresie.

Player.UserId, Player.User.Id i inne API silnika zwracają ten sam skuteczny identyfikator użytkownika dla użytkownika w twojej grze, więc istniejący kod, który odczytuje pola numerycznych identyfikatorów użytkowników, nadal działa bez logiki rozgałęziającej.

Otwarte żądania i odpowiedzi w chmurze używają tego samego skutecznego identyfikatora użytkownika dla docelowej domeny. Nie ujawniają drugiego identyfikatora użytkownika dla tego samego użytkownika w tej domenie.

Przechowywanie tożsamości użytkownika

Używaj numerycznego skutecznego identyfikatora użytkownika tylko do identyfikacji użytkownika w ramach jednej domeny. Klucz magazynu danych w jednej grze może używać user.Id bezpośrednio:

local key = ("player_%d"):format(player.User.Id)
PlayerDataStore:SetAsync(key, data)

Gdy inna domena odczytuje przechowywaną tożsamość, na przykład aplikacja OAuth, która moderuje użytkowników, przechowuj ciąg z ToString(). Ciąg koduje kontekst domeny razem ze skutecznym identyfikatorem użytkownika. Użycie samej liczby całkowitej może zastosować działanie do niewłaściwego użytkownika, gdy ta sama liczba identyfikuje innego użytkownika w innej domenie.

local encoded = player.User:ToString()
SomeDataStore:SetAsync("support_ticket_user", encoded)

-- Później, przywróć z ciągu
local user = User.fromString(encoded)

Aby uzyskać więcej informacji na temat gwarancji serializacji, zobacz dokumentację User.

Najlepsze praktyki

• Używaj Player.User jako standardowego identyfikatora w nowym kodzie.
• Używaj numerycznego skutecznego identyfikatora użytkownika tylko w ramach jednej domeny, takiej jak klucze magazynu danych dla jednej gry.
• Używaj ToString() oraz fromString(), gdy inna domena odczytuje przechowywaną tożsamość.

Kiedy używać Użytkownika lub Gracza

• Używaj Player do działań na serwerze: ruch postaci, GUI, teleportacja, czat, inwentarz.
• Używaj User do tożsamości, która przetrwa sesję: magazyny danych, narzędzia Open Cloud, odniesienia między grami.