DataModel

Ten właściwość opisuje ID użytkownika lub grupy, która posiada miejsce. Jeśli właściwość DataModel.CreatorType jest Użytkownikiem to wtedy CreatorId będzie ID grupy, która posiada miejsce. Jeśli właściwość Class.DataModel.Creator

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	if game.CreatorType == Enum.CreatorType.User then
		if player.UserId == game.CreatorId then
			print("The place owner has joined the game!")
		end
	elseif game.CreatorType == Enum.CreatorType.Group then
		if player:IsInGroup(game.CreatorId) then
			print("A member of the group that owns the place has joined the game!")
		end
	end
end)

To właściwość opisuje Enum.CreatorType miejsce, czy jest ono własnością użytkownika czy grupa.

Jeśli Enum.CreatorType jest Użytkownikiem, to właściwość DataModel.CreatorId opisuje 2> Class.Player.Player.Player2> z konta, które posiada gra. Jeśli typ jest 5>Grupa5>, to opisuje ona ID grupy.

local Players = game:GetService("Players")

Players.PlayerAdded:Connect(function(player)
	if game.CreatorType == Enum.CreatorType.User then
		if player.UserId == game.CreatorId then
			print("The place owner has joined the game!")
		end
	elseif game.CreatorType == Enum.CreatorType.Group then
		if player:IsInGroup(game.CreatorId) then
			print("A member of the group that owns the place has joined the game!")
		end
	end
end)

Ten właściwość opisuje ID doświadczenia, do którego serwer należy.

Ten identyfikator można znaleźć w górnym, prawym rogu Gestora zasobów w Roblox Studio. Gdy używasz Roblox Studio, jeśli miejsce nie zostało opublikowane do Roblox, to GameId będzie odpowiadać szablonowi używanej.

Zobacz również:

• DataModel.PlaceId , który opisuje ID miejsca uruchomionego na serwerze
• DataModel.JobId , który jest unikalnym identyfikatorem dla instancji serwera działającej
• TeleportService , który jest usługą, która może być używana do transportu Players między grami

To właściwość jest złamaна i nie powinna być używana.

Ta właściwość opisywała historycznie Enum.Genre lokalizacji jako ustawionej na stronie Roblox.

Ta właściwość, wraz z DataModel.GearGenreSetting, nie działa już poprawnie z powodu istniejących gatunków na stronie Roblox, które nie są odzwierciedlone w Enum.Genre zapisie. W wynikpróbując czytać tę właściwość, można wywołać błąd.

Ten identyfikator jest unikalnym identyfikatorem dla bieżącej instancji instancjagry. Jest to unikalny identyfikator (UUID), co oznacza, że żaden serwer, past lub present, nigdy nie będzie miał tego samego ID.

Domyślnie do pustej wartości w Studio.

Zobacz również

• TeleportService:GetPlayerPlaceInstanceAsync() , który można użyć do odzyskiwania DataModel.JobId serwera użytkownika.
• TeleportService:TeleportToPlaceInstance() , który można użyć do teleportacji Player na określony serwer.
• DataModel.PrivateServerId opisuje ID prywatnego serwera do którego należy instansja gry.
• HttpService:GenerateGUID() , funkcja, która może być używana do generowania własnych UUID.

To właściwość opisuje ID miejsca uruchomionego na serwerze.

Jeśli miejsce zostało opublikowane na Roblox, ten identyfikator można znaleźć w Asset Manager Studio, klikając prawym przyciskiem myszy na miejsce w katalogu Miejsce i wybierając Kopiuj ID do klipboard .

Jeśli miejsce nie zostało opublikowane na Roblox, ten identyfikator będzie odpowiadał szablonowi używanej.

Zobacz również

• DataModel.GameId , który opisuje ID doświadczenia, do którego obecny lokal należy
• DataModel.JobId , który jest unikalnym identyfikatorem dla instancji serwera działającej
• TeleportService , który jest usługą, która może być używana do transportu Players między miejscami

To właściwość opisuje wersję, na której serwer biec będzie.

Ten numer wersji odpowiada numerowi wersji pokazanemu w sekcji Historia wersji położenia. Nie jest to obecna wersja klienta Roblox. Ta właściwość ma 0 dla wszystkich nieopublikowanych doświadczeń.

Gdy dla miejsca utworzona zostanie instancja serwera, używa ona bieżącej wersji miejsca. Jeśli miejsce zostanie później zaktualizowane podczas uruchomienia tego serwera, serwer pozostanie przy swojej bieżącej wersji.

Ten element może być używany do wyświetlenia ScreenGui pokazującej obecną wersję gry dla Players aby pomóc z debugowaniem.

local StarterGui = game:GetService("StarterGui")

local versionGui = Instance.new("ScreenGui")

local textLabel = Instance.new("TextLabel")
textLabel.Position = UDim2.new(1, -10, 1, 0)
textLabel.AnchorPoint = Vector2.new(1, 1)
textLabel.Size = UDim2.new(0, 150, 0, 40)

textLabel.BackgroundTransparency = 1
textLabel.TextColor3 = Color3.new(1, 1, 1)
textLabel.TextStrokeTransparency = 0
textLabel.TextXAlignment = Enum.TextXAlignment.Right
textLabel.TextScaled = true

local placeVersion = game.PlaceVersion
textLabel.Text = string.format("Server version: %s", placeVersion)

textLabel.Parent = versionGui
versionGui.Parent = StarterGui

Ten właściwość opisuje private server ID serwera, jeśli serwer jest prywatnym serwerem.

Jeśli serwer nie jest prywatnym serwerem, to właściwość ta będzie pustą ciąg.

Prywatne serwery

Prywatne serwery odnoszą się do obserwuje:

• Prywatne serwery, które użytkownicy mogą kupić z strony gier
• Zarezerwowane serwery, prywatne serwery utworzone przez rozwiniętego używając TeleportService:ReserveServer()

PrivateServerId vs IdJob

PrivateServerId serwera jest inny od DataModel.JobId. JobId jest unikalnym identyfikatorem obecnego serwera instancja.

Prywatne serwery (serwery prywatne lub zachowane) mogą mieć wiele instancji serwera związanych z nimi w czasie. Dzieje się tak dlatego, że, choć tylko jedna instancja serwera może być uruchomiona na raz dla prywatnego serwera, nowe instancje serwera mogą otwierać i zamykać, gdy gracze dołączają i op

Zobacz również:

• DataModel.PrivateServerOwnerId , opis właściciela prywatnego serwera
• TeleportService:ReserveServer() , funkcja która tworzy zarezerwowany serwer

local function getServerType()
	if game.PrivateServerId ~= "" then
		if game.PrivateServerOwnerId ~= 0 then
			return "VIPServer"
		else
			return "ReservedServer"
		end
	else
		return "StandardServer"
	end
end

print(getServerType())

Ten właściwość opisuje UserId z Player , które posiada serwer prywatny jeśli serwer jest prywatne.

Jeśli serwer jest standardowy lub zachowuje rezerwowany serwer, to właściwość ta zostanie ustawiona na 0 .

Ten parametr może być używany do identyfikacji, czy Player jest właścicielem prywatnego serwera, na przykład:

local Players = game:GetService("Players")

-- czy to prywatny serwer?
if game.PrivateServerId ~= "" and game.PrivateServerOwnerId ~= 0 then

    -- słuchaj, gdy dodawane są nowi gracze
    Players.PlayerAdded:Connect(function(player)

        -- sprawdź, czy gracz jest właścicielem serwera
        if player.UserId == game.PrivateServerOwnerId then
            print("The private server owner has joined the game")
        end
    end)
end

Zobacz również:

• DataModel.PrivateServerId , właściwość opisująca unikalne ID prywatnych i reserved servers

local function getServerType()
	if game.PrivateServerId ~= "" then
		if game.PrivateServerOwnerId ~= 0 then
			return "VIPServer"
		else
			return "ReservedServer"
		end
	else
		return "StandardServer"
	end
end

print(getServerType())

Właściwość Workspace odnosi się do usługi Workspace.

Ta właściwość zawsze będzie wskazywała na Workspace i nigdy nie będzie nil.

Class.Workspace można również uzyskać poprzez globalną zmienne workspace i funkcję Class.ServiceProvider:GetService() . Na przykład:

workspace -- ogląlną zmienne
game.Workspace -- własność DataModel (gra)
game:GetService("Workspace") -- workspace is a service

Związuje funkcję, którą należy wywołać przed zamknięciem serwera. Jeśli związana funkcja akceptuje parametr, przesyła Enum.CloseReason określając powód zamknięcia serwera.

Możesz związać wiele funkcji, wykonując BindToClose() wiele razy. Funkcje związane są w pary i są wykonane równocześnie.

Serwer doświadczeń czeka 30 sekund, aby wszystkie powiązane funkcje przestały działać, zanim się go zamknie. Po 30 sekundach serwer zamknięty, nawet jeśli funkcje nadal będą działać.

Aby zweryfikować, że obecna sesja nie jest w Roblox Studio, użyj RunService:IsStudio() . To zapobiega zakończeniu funkcji wiązanych w sesjach testowych offline.

Gdy używasz DataStoreService, powinieneś również używać BindToClose, aby związać funkcję zapisu wszystkich niezapisanych danych na DataStores. To zapobiega utracie danych, jeśli serwer zostanie tymczasowo wyłączony.

Zobacz również:

• Enum.CloseReason dla powodów zamknięcia serwera doświadczeń.
• PluginGui:BindToClose() , który wiąże funkcję z przyciskiem zamknięcia PluginGui .

Parametry

Zwroty

local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")

local playerDataStore = DataStoreService:GetDataStore("PlayerData")

local allPlayerSessionDataCache = {}

local function savePlayerDataAsync(userId, data)
  return playerDataStore:UpdateAsync(userId, function(oldData)
    return data
  end)
end

local function onServerShutdown(closeReason)
  if RunService:IsStudio() then
    -- Avoid writing studio data to production and stalling test session closing
    return
  end

  -- Reference for yielding and resuming later
  local mainThread = coroutine.running()

  -- Counts up for each new thread, down when the thread finishes. When 0 is reached,
  -- the individual thread knows it's the last thread to finish and should resume the main thread
  local numThreadsRunning = 0

  -- Calling this function later starts on a new thread because of coroutine.wrap
  local startSaveThread = coroutine.wrap(function(userId, sessionData)
    -- Perform the save operation
    local success, result = pcall(savePlayerDataAsync, userId, sessionData)
    if not success then
      -- Could implement a retry
      warn(string.format("Failed to save %d's data: %s", userId, result))
    end

    -- Thread finished, decrement counter
    numThreadsRunning -= 1

    if numThreadsRunning == 0 then
      -- This was the last thread to finish, resume main thread
      coroutine.resume(mainThread)
    end
  end)

  -- This assumes playerData gets cleared from the data table during a final save on PlayerRemoving,
  -- so this is iterating over all the data of players still in the game that hasn't been saved
  for userId, sessionData in pairs(allPlayerSessionDataCache) do
    numThreadsRunning += 1

    -- This loop finishes running and counting numThreadsRunning before any of
    -- the save threads start because coroutine.wrap has built-in deferral on start
    startSaveThread(userId, sessionData)
  end

  if numThreadsRunning > 0 then
    -- Stall shutdown until save threads finish. Resumed by the last save thread when it finishes
    coroutine.yield()
  end
end

game:BindToClose(onServerShutdown)

game:BindToClose(function(closeReason)
	print(`Closing with reason {closeReason}`)
	task.wait(3)
	print("Done")
end)

Wyświetla tabelę zawierającą podstawowe informacje o zadaniach wykonanych przez kalendarz zadań.

W programowaniu kalendarz zadań jest systemem odpowiedzialnym za wykonanie kluczowych zadań w odpowiednich odstępach czasu.

Można również znaleźć statystyki kalendarza zadań w oknie kalendarza zadań w Roblox Studio.

Pierwszą pozycją w tabeli jest encyklopedia odniesień zawierająca statystyki (lub nagłówki) dostępne. Jest w następującej formie:

{
    ["name"] = "name",
    ["averageDutyCycle"] = "averageDutyCycle",
    ["averageStepsPerSecond"] = "averageStepsPerSecond",
    ["averageStepTime"] = "averageStepTime",
    ["averageError"] = "averageError",
    ["isRunning"] = "isRunning",
}

Kolejne wpisy w tabeli zwracają słowniki zawierające powyższe statystyki dla wykonanych zadań kalendarza. Na przykład:

{
    ["name"] = "Heartbeat",
    ["averageDutyCycle"] = 0,
    ["averageStepsPerSecond"] = 0,
    ["averageStepTime"] = 0,
    ["averageError"] = 0,
    ["isRunning"] = false,
}

Zobacz również:

• TaskScheduler

Zwroty

local jobInfo = game:GetJobsInfo()
local jobTitles = jobInfo[1]

table.remove(jobInfo, 1)

local divider = string.rep("-", 120)
print(divider)
warn("JOB INFO:")
print(divider)

for _, job in pairs(jobInfo) do
	for jobIndex, jobValue in pairs(job) do
		local jobTitle = jobTitles[jobIndex]
		warn(jobTitle, "=", jobValue)
	end
	print(divider)
end

Ten metod returnuje wielką pustą Instances związaną z podanym URL. Można go użyć do wstawienia treści z biblioteki Roblox. Nie jest możliwe wstawienie Sounds używając tego metodu, ponieważ nie mają one powiązanego Instance i tylko mają treści URL.

Odwróć InsertService:LoadAsset() , DataModel:GetObjects() nie wymaga, aby zasoby były "zaufane", co oznacza, że zasoby nie muszą być własnością zalogowanego użytkownika lub stworzonego przez Roblox, aby zostać wstawione. Jeśli zasoby nie są własnością zalogowanego użytkownika, muszą być wolnie dostępne.

Ze względu na kontekst bezpieczeństwa funkcji ten może być używany tylko przez wtyczki lub barę komend. Dla alternatywy, która może być używana w Scripts i LocalScripts, zobacz InsertService:LoadAsset().

Parametry

Zwroty

local Selection = game:GetService("Selection")

local WEB_URL = "plugin URL here"

local function downloadPlugin(webURL)
	-- get the content URL
	local contentID = string.match(webURL, "%d+")
	local contentURL = "rbxassetid://" .. contentID

	-- download the objects
	local objects = game:GetObjects(contentURL)

	-- decide where to parent them
	local selection = Selection:Get()
	local parent = #selection == 1 and selection[1] or workspace

	-- parent the objects
	for _, object in pairs(objects) do
		object.Parent = parent
	end
end

downloadPlugin(WEB_URL)

local IMAGES = {
	-- Insert Decal web URLs in an array here (as strings)
}

-- open the dictionary
local outputString = "textures = {"

-- utility function to add a new entry to the dictionary (as a string)
local function addEntryToDictionary(original, new)
	outputString = outputString
		.. "\n" -- new line
		.. "    " -- indent
		.. '["'
		.. original
		.. '"]' -- key
		.. ' = "'
		.. new
		.. '",' -- value
end

print("Starting conversion")

for _, webURL in pairs(IMAGES) do
	-- get the content URL
	local contentID = string.match(webURL, "%d+")
	local contentURL = "rbxassetid://" .. contentID

	local success, result = pcall(function()
		local objects = game:GetObjects(contentURL)
		return objects[1].Texture
	end)

	if success then
		addEntryToDictionary(webURL, result)
	else
		addEntryToDictionary(webURL, "Error downloading decal")
	end

	task.wait()
end

print("Conversion complete")

-- close the dictionary
outputString = outputString .. "\n}"

-- print the dictionary
print(outputString)

Funkcja ta zwraca prawdę, jeśli klient zakończył ładowanie gry po raz pierwszy.

Gdy wszystkie początkowe Instances w grze zakończą się kopiowaniem na klienta, ta funkcja zwróci prawdziwy.

Chyba że są one powiązane z ReplicatedFirst , LocalScripts nie będą działać, gdy gra nie załadowała się. Następny snippet, zaczął się z LocalScript w 1> Class.ReplicatedFirst1> i będzie wykonywany do czasu załadowania gry:

if not game:IsLoaded() then
    game.Loaded:Wait()
end

Zobacz również:

• DataModel.Loaded , wydarzenie, które się włącza, gdy gra zostanie załadowana
• Instance:WaitForChild() , funkcja, która może być używana do oczekiwania na osobisty Instance , aby się replikować, bez konieczności czekania na całą grę

Zwroty

local Players = game:GetService("Players")
local ReplicatedFirst = game:GetService("ReplicatedFirst")

local player = Players.LocalPlayer
local playerGui = player:WaitForChild("PlayerGui")

-- Create a basic loading screen
local screenGui = Instance.new("ScreenGui")
screenGui.IgnoreGuiInset = true

local textLabel = Instance.new("TextLabel")
textLabel.Size = UDim2.new(1, 0, 1, 0)
textLabel.BackgroundColor3 = Color3.fromRGB(0, 20, 40)
textLabel.Font = Enum.Font.GothamMedium
textLabel.TextColor3 = Color3.new(0.8, 0.8, 0.8)
textLabel.Text = "Loading"
textLabel.TextSize = 28
textLabel.Parent = screenGui

-- Parent entire screen GUI to player GUI
screenGui.Parent = playerGui

-- Remove the default loading screen
ReplicatedFirst:RemoveDefaultLoadingScreen()

--wait(3)  -- Optionally force screen to appear for a minimum number of seconds
if not game:IsLoaded() then
	game.Loaded:Wait()
end
screenGui:Destroy()

Funkcja ta ustawia DataModel.PlaceId instancji gry na placeId .

Aby uzyskać dostęp do DataModel.PlaceId , gdy miejsce nie jest opublikowane, wymagane jest ustawienie zarówno DataModel.GameId i Class.DataModel

local DataStoreService = game:GetService("DataStoreService")

-- dostęp do DataStore „Data” poprzez ustawienie PlaceId na miejsceId i GameId na universeId.
game:SetPlaceId(placeId)
game:SetUniverseId(universeId)
local dataStore = DataStoreService:GetDataStore("Data")

Parametry

Zwroty

Funkcja ta ustawia DataModel.GameId bieżącej instancji gry na uniwers danych. Jest to przydatne, gdy testujesz lokalne pliki .rbxl, które nie zostały opublikowane na Roblox.

Aby uzyskać dostęp do DataStoreService w miejscenieopublikowanym, zarówno DataModel:SetUniverseId() i DataModel:SetPlaceId() muszą być ustawiać.

Parametry

Zwroty

Wystrzeluje, gdy użytkownik wpisuje wzrost lub spadek jakości grafiki za pomocą klawiszy.

To wydarzenie działa na podstawie następujących warunków:

• Jeśli użytkownik naciśnie F10, ten ewent wyzwany zostanie z argumentem betterQuality z true.
• Jeśli użytkownik naciśnie ShiftF10, ten ewent wyzwany zostanie z argumentem betterQuality z 0> false0> .

Ten wątek nie dostarcza aktualnego poziomu jakości grafiki lub nie pokrywa wszystkich aktualizacji dotyczących jakości grafiki. Na przykład, zmiany dokonane w menu ucieczki z GUI nie są rejestrowane.

Możesz odzyskać użytkownika Enum.SavedQualitySetting używając UserGameSettings z następującym snippetem:

UserSettings():GetService("UserGameSettings").SavedQualityLevel

Jeśli ustawienia grafiki użytkownika są ustawione na automatyczne, to Enum.SavedQualitySetting będą Automatic. Obecnie nie ma sposobu dla rozwójców, aby wiarygodnie uzyskać obecny poziom jakości grafiki maszyny użytkownika.

Parametry

game.GraphicsQualityChangeRequest:Connect(function(betterQuality)
	if betterQuality then
		print("The user has requested an increase in graphics quality!")
	else
		print("The user has requested a decrease in graphics quality!")
	end
end)

Ten wątek zostanie uruchomiony na klientu, gdy gra po raz pierwszy zakończy się ładowaniem.

Wydarzenie Załadowane występuje, gdy wszystkie początkowe Instances w grze zostały zakończone replikacją na klienta.

Chyba że są one powiązane z ReplicatedFirst , LocalScripts nie będą działać przed tym wydarzeniem uruchomienia. Poniższy kod będzie wykonywany z LocalScript w 1> Class.ReplicatedFirst1>, aby uzyskać wynik do momentu ładowania gry:

if not game:IsLoaded() then
    game.Loaded:Wait()
end

Zobacz również:

• DataModel:IsLoaded() , funkcja która zwraca, czy gra jest załadowana lub nie
• Instance:WaitForChild() , funkcja, która może być używana do oczekiwania na osobisty Instance , aby się replikować, bez konieczności czekania na całą grę do wczytywać.