DataModel

Cette propriété décrit l'ID de l'utilisateur ou du groupe qui possède le emplacement. Si la propriété DataModel.CreatorType est 'User' alors CreatorId sera le Player.UserId de l'propriétairedu emplacement. Si la emplacement1> Class.DataModel.CreatorType

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)

Cette propriété décrit le Enum.CreatorType du emplacement, que le lieu soit détenu par un utilisateur ou un groupe.

Si le Enum.CreatorType est « utilisateur», alors la propriété DataModel.CreatorId décrit le 1> Class.Player.UserId|UID » de l' compte qui possède le jeu. Si le type de créateur est4> « Groupe »4>, il décrit l'identifiant du groupe.

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)

Cette propriété décrit l'ID de l'expérience à laquelle le lieu sur lequel le serveur s'exécute appartient.

Cet ID peut être trouvé dans le coin supérieur droit de la Gestionnaire des ressources dans Roblox Studio. Lors de l'utilisation de Roblox Studio, si l'endroit n'a pas été publié sur Roblox, alors l'Id de la ressource correspondra à l'emplacement utilisé.

Voir aussi :

• DataModel.PlaceId , qui décrit l'ID de l'endroit s'exécutant sur le serveur
• DataModel.JobId , qui est un identifiant unique pour l'instance de jeu du serveur en cours d'exécution
• TeleportService, qui est un service qui peut être utilisé pour transporter Players entre les jeux

Cette propriété est cassée et ne devrait pas être utilisée.

Cette propriété décrit historiquement le Enum.Genre du lieu comme établi sur le site Web de Roblox.

Cette propriété, ainsi que DataModel.GearGenreSetting, ne fonctionne plus correctement en raison des genres existants sur le site Web Roblox qui ne sont pas reflétés dans l' Enum.Genre enum. resultats, l'essayer de lire cette propriété peut générer une erreur.

Cette propriété est un identifiant unique pour l'instance de serveur de jeu en cours d'exécution. Il s'agit d'un identifiant unique universel (UUID), ce qui signifie que deux serveurs, passés ou présents, n'auront jamais le même ID.

Défauts à une chaîne vide dans Studio.

Voir aussi

• TeleportService:GetPlayerPlaceInstanceAsync() qui peut être utilisé pour récupérer le DataModel.JobId d'un utilisateur's serveur actuel.
• TeleportService:TeleportToPlaceInstance() qui peut être utilisé pour téléporter un Player sur un serveur spécifique.
• DataModel.PrivateServerId décrit l'ID du serveur privé auquel la classe de serveur de jeu appartient.
• HttpService:GenerateGUID() , une fonction qui peut être utilisée pour générer vos propres UUID.

Cette propriété décrit l'ID de l'endroit s'exécutant sur le serveur.

Si l'endroit a été publié sur Roblox, cet ID peut être trouvé dans le Gestionnaire des ressources de Studio en faisant un clic droit sur l'endroit à l'intérieur du dossier Lieux et en sélectionnant Copier l'ID dans le presse-papiers .

Si l'endroit n'a pas été publié sur Roblox, cet ID correspondra à l'emplacement utilisé.

Voir aussi

• DataModel.GameId , qui décrit l'ID de l'expérience à laquelle le lieu actuel appartient
• DataModel.JobId , qui est un identifiant unique pour l'instance de jeu du serveur en cours d'exécution
• TeleportService, qui est un service qui peut être utilisé pour transporter Players entre les lieux

Cette propriété décrit la version sur laquelle le serveur s'exécute.

Ce numéro de version correspond à la version numéro affichée dans la section Historique des versions des paramètres du emplacement. Ce n'est pas la version actuelle du client Roblox. Cette propriété est 0 pour toutes les expériences non publiées.

Lorsqu'une instance de serveur est créée pour un emplacement, il utilise la version actuelle du emplacement. Si le lieu est plus tard mis à jour pendant l'exécution de ce serveur, le serveur restera à sa version actuelle.

Cette propriété peut être utilisée pour afficher un ScreenGui montrant la version actuelle du jeu à Players pour aider au débogage.

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

Cette propriété décrit l'identifiant du serveur privé du serveur, si le serveur est un serveur privé.

Si le serveur n'est pas un serveur privé, cette propriété sera une chaîne vide.

Serveurs privés

Les serveurs privés se réfèrent aux éléments suivre:

• Serveurs privés que les utilisateurs peuvent acheter à partir de la page des jeux
• Serveurs réservés, serveurs privés créés par le développeur en utilisant TeleportService:ReserveServer()

PrivateServerId vs JobId

L'identifiant privé d'un serveur est différent de l'identifiant de DataModel.JobId . Le JobId est l'identifiant unique de l'instance de serveur actuelle.

Les serveurs privés (serveurs privés ou réservés) peuvent avoir plusieurs serveurs associés avec eux au fil du temps. C'est parce que, bien que seul un serveur à la fois ne puisse pas s'exécuter, de nouvelles instances de serveur peuvent s'ouvrir et se fermer à mesure que les joueurs rejoignent et quittent le jeu. Par exemple, aucune instance de serveur ne s'exécute lorsque personne ne joue dans le serveur

Voir aussi :

• DataModel.PrivateServerOwnerId , une propriété décrivant le propriétaire d'un serveur privé
• TeleportService:ReserveServer() , une fonction qui crée un serveur réservé

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

Cette propriété décrit la UserId de la Player qui possède le serveur privé si le serveur est privé.

Si le serveur est un serveur standard ou réservé, cette propriété sera définie sur 0 .

Cette propriété peut être utilisée pour identifier si un Player est le propriétaire du serveur privé, par exemple :

local Players = game:GetService("Players")

-- est-ce qu'il s'agit d'un serveur privé ?
if game.PrivateServerId ~= "" and game.PrivateServerOwnerId ~= 0 then

    -- écouter de nouveaux joueurs ajoutés
    Players.PlayerAdded:Connect(function(player)

        -- vérifier si le joueur est le propriétaire du serveur
        if player.UserId == game.PrivateServerOwnerId then
            print("The private server owner has joined the game")
        end
    end)
end

Voir aussi :

• DataModel.PrivateServerId , une propriété décrivant l'ID unique des serveurs privés et 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())

La propriété Workspace fait référence au service Workspace.

Cette propriété poindra toujours sur le Workspace et ne sera jamais zéro.

Le Workspace peut également être accédé à l'aide de la variable globale workspace et de la fonction ServiceProvider:GetService(). Par exemple :

workspace -- une variable globale
game.Workspace -- une propriété du DataModel (jeu)
game:GetService("Workspace") -- workspace is a service

Lie une fonction à être appelée avant la fermeture du serveur. Si la fonction liée accepte un argument, il passe Enum.CloseReason spécifiant la raison pour laquelle le serveur s'est fermé.

Vous pouvez lier plusieurs fonctions en appelant BindToClose() à plusieurs reprises. Les fonctions liées s'exécuteront en parallèle et s'exécuteront en même temps.

Le serveur d'expérience attend 30 secondes avant que toutes les fonctions liées s'arrêtent avant qu'il ne s'arrête. Après 30 secondes, le serveur s'arrête même si les fonctions sont toujours en cours d'exécution.

Pour vérifier que la session actuelle n'est pas dans Roblox Studio, utilisez RunService:IsStudio() . Cela empêche les fonctions liées de s'exécuter dans leurs sessions de test en ligne.

Lorsque vous utilisez DataStoreService, vous devriez également utiliser BindToClose pour lier une fonction enregistrant tous les données non enregistrées à DataStores. Cela évite la perte de données si le serveur s'arrête inattendument.

Voir aussi :

• Enum.CloseReason pour les raisons de la fermeture du serveur d'expérience.
• PluginGui:BindToClose() , qui lie une fonction à un bouton de fermeture PluginGui .

Paramètres

Retours

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)

Renvoie une table contenant des informations de base sur les tâches effectuées par le planificateur de tâches.

Dans la programmation, un calendrier de tâche est un système responsable de l'exécution de tâches clés à des intervalles appropriés.

Vous pouvez également trouver des statistiques sur l'horaire des tâches dans la fenêtre Planificateur de tâches dans Roblox Studio.

La première entrée dans le tableau renvoyée est un dictionnaire de référence contenant les statistiques (ou en-têtes) disponibles. Il est dans le format suivant :

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

Les entrées suivantes dans le tableau renvoyées sont des dictionnaires contenant les statistiques ci-dessus pour les tâches effectuées par le planificateur de tâches. Par exemple :

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

Voir aussi :

• TaskScheduler

Retours

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

Cette méthode renvoie un tableau de Instances associé avec l'URL de contenu donnée. Il peut être utilisé pour insérer du contenu à partir de la bibliothèque Roblox. Il n'est pas possible d'insérer Sounds en utilisant cette méthode car ils n'ont pas de Instance associé à eux et n'ont qu'un URL de contenu.

Contrairement à InsertService:LoadAsset() , DataModel:GetObjects() ne nécessite pas qu'une ressource soit «trustée», ce qui signifie qu'une ressource n'a pas besoin d'être possédée par l'utilisateur connecté, ou créée par Roblox, pour être insérée. Cependant, si la ressource n'est pas possédée par l'utilisateur connecté, elle doit être disponible librement.

En raison du contexte de sécurité de cette fonction, il ne peut être utilisé que par les plugins ou la barre de commande. Pour un alternative qui peut être utilisée dans Scripts et LocalScripts, voir InsertService:LoadAsset().

Paramètres

Retours

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)

Cette fonction retourne vrai si le client a fini de charger le jeu pour la première fois.

Lorsque tous les Instances du jeu ont terminé de se répliquer au client, cette fonction retournera vrai.

À moins qu'ils ne soient parentés à ReplicatedFirst , LocalScripts ne s'exécuteront pas pendant que le jeu n'a pas été chargé. Le script suivant, couru à partir d'un LocalScript dans 1> Class.ReplicatedFirst1> ne produira pas jusqu'à ce que le jeu ait chargé :

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

Voir aussi :

• DataModel.Loaded , un événement qui se déclenche lorsque le jeu a été chargé
• Instance:WaitForChild() , une fonction qui peut être utilisée pour attendre un individu Instance à se répliquer sans avoir à attendre que le jeu entier se

Retours

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

Cette fonction définie le DataModel.PlaceId de la instance de jeu sur le lieu donné placeId.

Les valeurs de DataModel.PlaceId et DataModel.GameId sont requises pour accéder à DataStoreService lorsque le lieu n'est pas publié, par exemple un fichier local 2>

local DataStoreService = game:GetService("DataStoreService")

-- accédez à DataStore « Data » en définissant PlaceId pour placer Id et GameId à universeId.
game:SetPlaceId(placeId)
game:SetUniverseId(universeId)
local dataStore = DataStoreService:GetDataStore("Data")

Paramètres

Retours

Cette fonction définie le DataModel.GameId de la instance de jeu actuelle sur le universeId donné. Ceci est utile lors du test des fichiers .rbxl locaux qui ne sont pas publiés sur Roblox.

Pour accéder au DataStoreService dans un emplacementnon publié, les deux DataModel:SetUniverseId() et DataModel:SetPlaceId() doivent être configurer.

Paramètres

Retours

Démarre lorsque l'utilisateur demande une augmentation ou une diminution de la qualité des graphiques en utilisant les raccourcis clavier.

Cet événement se déclenche sous les conditions suivantes :

• Si l'utilisateur appuie sur F10, cet événement se déclenche avec un argument betterQuality de true.
• Si l'utilisateur appuie sur MajF10 , cet événement se déclenche avec un argument betterQuality de 0> false0> .

Cet événement ne fournit pas le niveau de qualité des graphiques actuel ou couvre pas toutes les mises à jour de la qualité des graphiques. Par exemple, les modifications apportées dans le menu d'évasion de la GUI du noyau ne sont pas enregistrées.

Vous pouvez récupérer un utilisateur's Enum.SavedQualitySetting à l'aide de UserGameSettings avec le snippet suivant :

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

Si les paramètres graphiques de l'utilisateur sont réglés sur automatique, alors le Enum.SavedQualitySetting sera Automatic. Il n'y a actuellement aucun moyen pour les développeurs de obtenir le niveau de qualité graphique actuel d'une machine d'un utilisateur.

Paramètres

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)

Cet événement se déclenche sur le client lorsque le jeu se termine de charger pour la première fois.

L'événement Chargé se déclenche lorsque tous les Instances du jeu ont terminé de se répliquer sur le client.

À moins qu'ils ne soient parentés à ReplicatedFirst , LocalScripts ne s'exécutera pas avant cet événement de tir. Le snippet suivant, couru à partir d'un LocalScript dans 1> Class.ReplicatedFirst1>, s'exécutera jusqu'à ce que le jeu ait chargé :

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

Voir aussi :

• DataModel:IsLoaded() , une fonction qui renvoie si le jeu est chargé ou non
• Instance:WaitForChild() , une fonction qui peut être utilisée pour attendre un individu Instance à se répliquer sans avoir à attendre que le jeu se chargerentièrement.