Туториал · Данные игрока

Как сохранять данные игрока в Roblox Studio через DataStore

Roblox ничего не помнит об игроке между сессиями, если серверный скрипт это не сохранил. В этом гайде вы соберёте модуль PlayerData, который загружает, держит в памяти и сохраняет данные каждого игрока через DataStoreService, а затем разберёте проверку, лимиты и то, как сохранённые данные теряются.

Обновлено 12 ноября 2026 г.16 мин чтенияАвтор:

Коротко

Используйте DataStoreService из серверного Script: загружайте данные игрока через GetAsync, когда он заходит, держите их в таблице, пока он играет, и сохраняйте через UpdateAsync по таймеру, при выходе (PlayerRemoving) и при выключении сервера (game:BindToClose). Оборачивайте каждый вызов в pcall и повторяйте неудачные несколько раз.

  • Чтобы проверять в Studio, опубликуйте плейс и включите File > Experience Settings > Security > Enable Studio Access to API Services в отдельной тестовой игре: Studio использует те же данные, что и живые серверы.
  • Если данные игрока не загрузились, никогда не сохраняйте этого игрока. Сохранение значений по умолчанию затрёт его настоящий прогресс.
  • Храните одну таблицу на игрока под одним ключом, например User_12345, и сохраняйте по таймеру, а не при каждом изменении.
  • Для обмена предметами или платных предметов добавьте блокировку сессии, чтобы два сервера не могли сохранять одного игрока.
На этой странице
  1. Доступ Studio
  2. Как работает DataStore
  3. GetAsync и UpdateAsync
  4. 1. Модуль PlayerData
  5. Как устроен модуль
  6. 2. Работа с данными
  7. 3. Предупреждение
  8. 4. Проверка в Studio
  9. Почему теряются данные
  10. Блокировка сессии
  11. Лимиты
  12. Версии и копии
  13. Common errors
  14. With RoCode
  15. Частые вопросы
  16. Источники и что почитать

Перед началом: включите доступ Studio в тестовой копии

Игра, запущенная в Studio, не может обращаться к хранилищам данных, пока вы это не разрешите. У разрешения есть подвох, о котором предупреждает документация Roblox: Studio тогда читает и пишет те же хранилища данных, что и живая игра, поэтому тест, который обнуляет ваши монеты в Studio, обнуляет их и в живой игре, а ошибка в тестовом коде может испортить ключи настоящих игроков.

  1. Сделайте тестовую копию. Сохраните плейс в файл, откройте копию, выберите File > Publish to Roblox As и нажмите Create new game. Не добавляйте её как плейс внутри живой игры: все плейсы одной игры делят одни и те же хранилища данных.
  2. В тестовой копии откройте File > Experience Settings и перейдите в Security.
  3. Включите Enable Studio Access to API Services и нажмите Save.

Вызовы хранилищ данных работают только в серверных Script; LocalScript, который попробует, получит ошибку, поэтому клиенты не могут записывать сохранённые данные. Когда кнопка должна их менять, клиент просит сервер через RemoteEvent, и решает сервер (смотрите гайд по RemoteEvents, на английском).

Как хранилища данных хранят данные игроков

ИллюстрацияПроверка из шага 4 гайда в ускоренном виде: Play, Stop сохраняет сессию в хранилище данных, повторный Play загружает её, поэтому Output показывает 200.

Хранилище данных (data store) это именованный набор ключей и значений на серверах Roblox, общий для всех серверов и всех плейсов вашей игры. DataStoreService:GetDataStore("PlayerData") возвращает одно такое хранилище.

Рекомендации Roblox сводятся к правилу одно хранилище для данных игроков, один ключ на игрока, одна таблица в каждом ключе. Составляйте ключ из UserId игрока, например User_12345, и никогда из имени, которое он может сменить. Постоянный шаблон User_{UserId} также позволяет автоматической обработке Roblox по праву на забвение найти данные игрока, если вы её настроите.

Что можно сохранить в хранилище данных
ТипСохраняется?Примечания
Числа, строки, булевы значения, буферыДаСтроки должны быть корректным UTF-8. Не храните inf или nan.
ТаблицыДаЕсли всё внутри тоже можно сохранить. Таблица, чьи числовые ключи начинаются не с 1 (поэтому её длина 0), возвращается с этими ключами в виде строк.
Instance, Vector3, CFrame, Color3НетСохранение выдаёт ошибку или записывает nil. Сохраняйте имя предмета или позицию тремя числами.

Каждый запрос это веб-вызов, который может не пройти, занимает время и расходует поминутный бюджет. Поэтому надёжные системы сохранения читают данные один раз при входе игрока, держат их в серверной таблице, пока он играет, и время от времени записывают обратно.

GetAsync, SetAsync или UpdateAsync: что выбрать

Основные методы хранилища данных
МетодЧто делаетДля чего
GetAsync(key)Читает значение. Результат кэшируется на этом сервере на 4 секунды.Загрузка данных игрока
SetAsync(key, value)Перезаписывает значение, не читая его. Одна запись.Новый ключ или значение, которое не зависит от старого
UpdateAsync(key, callback)Читает последнее значение, передаёт его вашей функции и записывает то, что она вернёт. Одно чтение и одна запись.Сохранение данных игрока и любой ключ, который могут писать несколько серверов
IncrementAsync(key, delta)Прибавляет целое число к сохранённому целому числу.Счётчики
RemoveAsync(key)Удаляет ключ и возвращает старое значение. Прежние версии по-прежнему можно перечислить и прочитать.Удаление данных игрока

SetAsync пишет вслепую: если два сервера сохраняют один ключ почти одновременно, побеждает последняя запись, что бы в ней ни было. UpdateAsync сначала читает текущее значение, и если в промежутке пишет другой сервер, Roblox снова запускает вашу функцию с новым значением. Roblox советует его всегда, когда запись зависит от текущего значения или ключ могут писать несколько серверов, а это как раз данные игрока. У функции три правила:

  • Она не должна уступать выполнение (yield): никаких task.wait() и других вызовов хранилищ внутри.
  • Она может выполниться больше одного раза, поэтому должна только вычислять новое значение и никогда не выдавать предметы и не запускать события.
  • Возврат nil отменяет запись. Модуль использует это, чтобы не перезаписать данные, сохранённые более новой версией игры.

Шаг 1: создайте модуль PlayerData

Этот ModuleScript единственный код, который общается с хранилищем данных. Он загружает данные игрока при входе, держит их в памяти, сохраняет каждые 180 секунд, при выходе и при выключении сервера и отказывается сохранять тех, чьи данные не загрузились.

  1. В Explorer наведите курсор на ServerScriptService, нажмите + и вставьте ModuleScript. Переименуйте его в PlayerData и замените содержимое кодом ниже.
  2. ModuleScript выполняется только тогда, когда его подключает (require) какой-то скрипт. Вставьте в ServerScriptService Script с именем Main и такой строкой: local PlayerData = require(game:GetService("ServerScriptService").PlayerData). Другие серверные скрипты подключают его так же.
  3. Измените DEFAULTS и тип Data под свою игру, оставляя каждое поле числом, строкой, булевым значением или таблицей.
Explorer после шагов 1-3
ServerScriptService
    PlayerData ModuleScript new
    Main Script new
StarterPlayer
    StarterPlayerScripts
        DataWarning LocalScript new
ModuleScript в ServerScriptService с именем PlayerData
-- PlayerData: загружает данные игрока при входе, держит их в памяти
-- и сохраняет по таймеру, при выходе и при выключении сервера.
-- Другие серверные скрипты читают и меняют их через PlayerData.Get(player).

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

local STORE_NAME = "PlayerData"
local SCHEMA_VERSION = 2 -- повышайте, когда меняется форма данных, и добавляйте шаг в migrate()
local AUTOSAVE_SECONDS = 180
-- В Studio неудачный вызов сдаётся сразу, поэтому тест без доступа к хранилищу идёт быстро
local MAX_ATTEMPTS = if RunService:IsStudio() then 1 else 4
local FIRST_RETRY_SECONDS = 1 -- удваивается после каждой неудачи: 1, 2, 4

export type Data = {
	SchemaVersion: number,
	Coins: number,
	Level: number,
	Inventory: { string },
}

-- С чем начинает совсем новый игрок
local DEFAULTS: { [string]: any } = {
	Coins = 0,
	Level = 1,
	Inventory = {},
}

type Session = {
	key: string,
	userId: number,
	data: Data,
	canSave: boolean, -- false, если загрузка не удалась: данные по умолчанию не должны заменить настоящий прогресс
}

-- Вызывается внутри каждого pcall ниже, поэтому ещё не опубликованный плейс
-- (без доступа к хранилищу) всё равно загружает игроков с данными по умолчанию
local function store(): DataStore
	return DataStoreService:GetDataStore(STORE_NAME)
end
local sessions: { [Player]: Session } = {}
local pendingSaves: { [string]: number } = {} -- сохранения, которые ещё идут, по ключам
local loadedEvent = Instance.new("BindableEvent")

local PlayerData = {}

-- Срабатывает с игроком, когда его данные готовы. Таблицу берите через PlayerData.Get(player):
-- таблица, отправленная через BindableEvent, приходит копией, и её изменение ничего не изменит.
PlayerData.Loaded = loadedEvent.Event

local function deepCopy(value: any): any
	if type(value) ~= "table" then
		return value
	end
	local copy = {}
	for key, item in value do
		copy[key] = deepCopy(item)
	end
	return copy
end

local function defaultData(): Data
	local data = deepCopy(DEFAULTS) -- свежая копия, чтобы игроки никогда не делили одну таблицу Inventory
	data.SchemaVersion = SCHEMA_VERSION
	return data
end

-- Приводит сохранённые данные к текущей схеме. Возвращает nil, если их нельзя безопасно использовать.
local function migrate(saved: any): Data?
	if type(saved) ~= "table" then
		return nil
	end
	local version = tonumber(saved.SchemaVersion) or 1
	if version > SCHEMA_VERSION then
		return nil -- сохранено более новой версией игры: здесь не загружать и не перезаписывать
	end

	-- По одному шагу на изменение схемы, от старых к новым
	if version < 2 then
		-- Пример: в версии 1 валюта называлась Gold. Копируем её, только если Coins нет,
		-- чтобы старые данные, где Coins уже есть, но нет SchemaVersion, сохранили значение.
		if saved.Coins == nil then
			saved.Coins = saved.Gold
		end
		saved.Gold = nil
	end

	-- Добавляем поля, появившиеся после последнего сохранения игрока, и заменяем значения неверного типа
	for field, default in DEFAULTS do
		if type(saved[field]) ~= type(default) then
			saved[field] = deepCopy(default)
		end
	end
	saved.SchemaVersion = SCHEMA_VERSION
	return saved
end

-- Выполняет вызов хранилища в pcall. При неудаче ждёт и пробует снова, каждый раз удваивая
-- ожидание и добавляя немного случайности, чтобы серверы не повторяли все разом.
local function withRetries(label: string, call: () -> any): (boolean, any)
	for attempt = 1, MAX_ATTEMPTS do
		local ok, result = pcall(call)
		if ok then
			return true, result
		end
		warn(`{label} failed (attempt {attempt} of {MAX_ATTEMPTS}): {result}`)
		if attempt < MAX_ATTEMPTS then
			local waitTime = FIRST_RETRY_SECONDS * 2 ^ (attempt - 1)
			task.wait(waitTime + math.random() * waitTime / 2)
		end
	end
	return false, nil
end

local function save(session: Session): boolean
	if not session.canSave then
		return false
	end
	local key = session.key
	pendingSaves[key] = (pendingSaves[key] or 0) + 1

	local newerSchema = false
	local ok = withRetries(`Save {key}`, function()
		return store():UpdateAsync(key, function(current: any)
			if type(current) == "table" and (tonumber(current.SchemaVersion) or 1) > SCHEMA_VERSION then
				newerSchema = true
				return nil -- возврат nil отменяет запись
			end
			-- Пишем всю текущую таблицу с пометкой UserId игрока
			return session.data, { session.userId }
		end)
	end)

	local left = (pendingSaves[key] or 1) - 1
	if left > 0 then
		pendingSaves[key] = left
	else
		pendingSaves[key] = nil
	end
	if newerSchema then
		session.canSave = false
		warn(`{key} was saved by a newer version of the game, so this server stopped saving it`)
	end
	return ok and not newerSchema
end

local function startAutosave(player: Player, session: Session)
	task.spawn(function()
		-- Начинаем в случайный момент интервала, чтобы серверы не сохраняли все разом
		task.wait(math.random() * AUTOSAVE_SECONDS)
		while sessions[player] == session do
			save(session)
			task.wait(AUTOSAVE_SECONDS)
		end
	end)
end

local function load(player: Player)
	local key = "User_" .. player.UserId

	-- Если игрок только что вышел с этого сервера и вернулся, сначала даём закончиться последнему сохранению
	while pendingSaves[key] do
		task.wait()
	end

	local ok, saved = withRetries(`Load {key}`, function()
		return store():GetAsync(key)
	end)
	if player.Parent ~= Players then
		return -- вышел во время загрузки: ничего не изменилось, сохранять нечего
	end

	local data: Data? = nil
	if ok then
		data = if saved == nil then defaultData() else migrate(saved)
	end

	local session: Session = {
		key = key,
		userId = player.UserId,
		data = data or defaultData(),
		canSave = data ~= nil,
	}
	if not session.canSave then
		warn(`Could not load {key}. {player.Name} is playing on default data that will not be saved.`)
	end

	sessions[player] = session
	player:SetAttribute("DataLoaded", session.canSave) -- GUI может прочитать это и предупредить игрока
	startAutosave(player, session)
	loadedEvent:Fire(player)
end

local function endSession(player: Player)
	local session = sessions[player]
	if not session then
		return
	end
	sessions[player] = nil -- останавливает цикл автосохранения, и повторный вызов ничего не делает
	save(session)
end

-- Живая таблица данных игрока или nil, пока она не загрузилась. Меняйте её только из серверных скриптов.
function PlayerData.Get(player: Player): Data?
	local session = sessions[player]
	return if session then session.data else nil
end

-- True, когда данные игрока загрузились и будут сохранены. Проверяйте перед любой продажей.
function PlayerData.CanSave(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and session.canSave
end

-- Сохраняет сейчас, не дожидаясь таймера, для важных моментов вроде покупки.
-- Уступает выполнение и возвращает true, когда сохранение прошло.
function PlayerData.SaveNow(player: Player): boolean
	local session = sessions[player]
	return session ~= nil and save(session)
end

Players.PlayerAdded:Connect(load)
Players.PlayerRemoving:Connect(endSession)
for _, player in Players:GetPlayers() do
	task.spawn(load, player) -- игроки, зашедшие до первого подключения этого модуля
end

game:BindToClose(function()
	-- Сервер даёт этим функциям 30 секунд, поэтому сохраняем всех одновременно
	for player in sessions do
		task.spawn(endSession, player)
	end
	-- Затем ждём все ещё идущие сохранения, включая начатые в PlayerRemoving
	while next(pendingSaves) do
		task.wait()
	end
end)

return PlayerData

Когда игра вышла, не меняйте STORE_NAME и шаблон ключа User_. Изменение любого из них направит модуль на пустые ключи, и каждый игрок начнёт заново со значений по умолчанию.

Как модуль бережёт данные

Значения по умолчанию и версия схемы

Новый игрок получает свежую копию DEFAULTS. Это должна быть именно копия: если бы все игроки делили одну таблицу Inventory, предмет, добавленный одному, появился бы у всех.

Каждая сохранённая таблица несёт SchemaVersion. Добавление поля не требует новой версии, потому что migrate заполняет недостающие поля из значений по умолчанию. Переименование или перестройка требует: повысьте SCHEMA_VERSION и добавьте шаг, как в примере, который переименовывает Gold в Coins (в новой игре удалите его и начните с 1). Данные с версией выше, чем у сервера, пришли от более нового релиза, который ещё раскатывается, поэтому старые серверы их не трогают.

Неудачная загрузка никогда не сохраняется

Это правило защищает от полного стирания. Если все попытки загрузки не удались, игрок играет на данных по умолчанию, но canSave равно false, поэтому эти значения никогда не перезапишут его настоящий прогресс. Модуль также ставит атрибут DataLoaded в false, и шаг 3 использует его, чтобы сообщить игроку. Эталонный пример Roblox обрабатывает неудачные загрузки так же и предлагает это вместо кика; если вы предпочитаете кикать, вызовите player:Kick() с сообщением там, где модуль выводит предупреждение.

Повторы с нарастающей паузой

withRetries оборачивает каждый вызов в pcall. После неудачи он ждёт 1, затем 2, затем 4 секунды, каждый раз плюс случайно до половины этого времени, и останавливается после четырёх попыток (в Studio после одной, чтобы плейс без доступа к хранилищу запускался сразу). Случайность разносит повторы множества серверов после сбоя, а ограничение держит ожидание в пределах примерно 10 секунд, внутри 30 секунд, которые сервер получает на выключение. Поскольку каждое сохранение пишет всю живую таблицу через UpdateAsync, повтор, завершившийся с опозданием, не может вернуть старые данные.

Когда модуль сохраняет

КогдаЗачем
Каждые 180 секунд, пока игрок на сервереОграничивает потери при падении. Первое сохранение приходится на случайный момент интервала, чтобы серверы не сохраняли все разом. Эталонный пример Roblox тоже использует 180 секунд.
Когда игрок выходит (PlayerRemoving)Обычное финальное сохранение. Сессия сначала удаляется, поэтому автосохранение останавливается.
Когда сервер выключается (game:BindToClose)Все, кто ещё на сервере, сохраняются разом, и функция ждёт каждое идущее сохранение. Roblox даёт ей 30 секунд.
По запросу, через PlayerData.SaveNow(player)После того, что нельзя потерять, например покупки.

Если игрок снова заходит на тот же сервер, пока его финальное сохранение ещё идёт, новая загрузка ждёт окончания этого сохранения, поэтому не может прочитать старое значение.

Шаг 2: читайте и меняйте данные из других скриптов

Все серверные скрипты, подключающие модуль, работают с одними и теми же таблицами:

ВызовЧто делает
PlayerData.Get(player)Живая таблица данных игрока или nil, пока она не загрузилась. Меняйте поля напрямую, например data.Coins += 10, и следующее сохранение это подхватит.
PlayerData.LoadedСрабатывает с игроком, когда его данные готовы, в том числе после неудачной загрузки. Передаёт только игрока, потому что таблица, отправленная через BindableEvent, приходит копией.
PlayerData.CanSave(player)false, если загрузка не удалась. Проверяйте перед любой продажей: покупка, которую нельзя сохранить, пропадёт, когда игрок выйдет.
PlayerData.SaveNow(player)Сохраняет сразу и возвращает true, если получилось. Уступает выполнение.

Модуль единственное место, где живут сохранённые данные, а leaderstats только отображение: соберите его как в гайде по таблице лидеров, заполните из PlayerData.Get(player) в обработчике Loaded и обновляйте оба при изменении значения. Никогда не читайте сохранённые значения обратно из leaderstats и никогда не позволяйте второму скрипту сохранять тот же ключ.

Скрипт, подключивший модуль после того, как игроки зашли, пропускает для них Loaded. Подключите обработчик, а затем ещё пройдите циклом по Players:GetPlayers() и обработайте всех, для кого PlayerData.Get(player) уже возвращает таблицу.

Заменяете старый скрипт сохранения, например из гайда по таблице лидеров? Его значения остаются в его собственном хранилище и ключе, поэтому этот модуль начнёт всех со значений по умолчанию. До запуска либо направьте STORE_NAME и префикс User_ на старые (migrate считает данные без SchemaVersion версией 1 и заполняет недостающие поля), либо перенесите старые значения, а затем удалите старый скрипт.

Клиенты никогда не меняют эти данные напрямую. Кнопка магазина запускает RemoteEvent; сервер проверяет CanSave, сравнивает цену с Coins игрока, меняет таблицу и вызывает SaveNow. Гайд по GUI магазина собирает такую покупку на стороне сервера.

Готовый пример добавления полей есть в гайде по кликер-симулятору: он добавляет PowerLevel и Rebirths в DEFAULTS и тип Data, а затем меняет их в таблице, которую возвращает PlayerData.Get. migrate выдаёт новые поля игрокам со старыми сохранениями.

Шаг 3: сообщите игроку, что его данные не загрузились

Игрок, чьи данные не загрузились, должен знать, что эта сессия не сохранится, чтобы перезайти, а не играть впустую. Этот LocalScript следит за атрибутом DataLoaded и показывает баннер, когда он равен false.

LocalScript в StarterPlayerScripts с именем DataWarning
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local shown = false

local function showWarning()
	if shown or player:GetAttribute("DataLoaded") ~= false then
		return
	end
	shown = true

	local gui = Instance.new("ScreenGui")
	gui.Name = "DataWarning"
	gui.ResetOnSpawn = false

	local label = Instance.new("TextLabel")
	label.AnchorPoint = Vector2.new(0.5, 0)
	label.Position = UDim2.new(0.5, 0, 0, 12)
	label.Size = UDim2.new(0.8, 0, 0, 48)
	label.BackgroundColor3 = Color3.fromRGB(110, 28, 28)
	label.TextColor3 = Color3.new(1, 1, 1)
	label.TextScaled = true
	label.Text = "Your saved progress could not be loaded. Nothing you do in this server will be saved, so rejoin later."
	label.Parent = gui

	gui.Parent = player:WaitForChild("PlayerGui")
end

-- Сервер ставит DataLoaded один раз, после попытки загрузить данные этого игрока
player:GetAttributeChangedSignal("DataLoaded"):Connect(showWarning)
showWarning()

Шаг 4: проверьте сохранение в Studio

Делайте это в тестовой копии с включённым доступом Studio.

  1. Дайте себе что-нибудь для сохранения. Под строкой require в Main добавьте: PlayerData.Loaded:Connect(function(player) local data = PlayerData.Get(player) if data then data.Coins += 100 print(player.Name, data.Coins) end end)
  2. Нажмите Play. Окно Output (в меню Window или на вкладке Script) покажет ваше имя и 100 (при первом запуске), без предупреждения Could not load.
  3. Нажмите Stop. Завершение теста закрывает сервер, и модуль сохраняет вас до закрытия.
  4. Снова нажмите Play. Output должен показать 200, на 100 больше прошлого раза. Если он снова показывает то же число, сохранение не прошло: прочитайте предупреждения над ним.
  5. Проверьте путь с ошибкой. Выключите доступ Studio и нажмите Play. После нескольких секунд повторов Output покажет Could not load User_... и 100, и появится баннер из шага 3. Остановите тест, снова включите доступ и нажмите Play: Output покажет 300, ваши сохранённые 200 плюс 100, потому что неудачная сессия так и не перезаписала ваши данные.
  6. Удалите тестовую строку из Main.

Почему теряются данные игроков

Вот обычные способы, которыми система сохранения теряет прогресс. Модуль закрывает в коде первые четыре строки и строку про схему; остальные зависят от того, что и как вы храните, а для последней нужна блокировка сессии.

Что происходитРезультатКак предотвратить
Загрузка не удалась, а скрипт всё равно сохраняетЗначения по умолчанию затирают настоящий прогресс: полное стираниеНикогда не сохранять игрока, чья загрузка не удалась
Сохранение только в PlayerRemovingПадение или выключение сервера пропускает сохранениеАвтосохранение плюс BindToClose, который ждёт свои сохранения
Нет pcall или нет повтораОдин неудачный запрос останавливает скрипт или теряет сохранениеpcall с несколькими разнесёнными по времени повторами
Сохранение при каждом измененииЗапросы встают в очередь; когда в очереди 30, новые отбрасываютсяДержать данные в памяти и сохранять по таймеру
Сохранение того, что хранилище не умеет хранитьСохранение выдаёт ошибку, или значение возвращается nilСохранять числа, строки, булевы значения и таблицы из них
Изменение формы данных без миграцииСтарые сохранения загружаются не в те поляВерсия схемы и шаг миграции
Два скрипта сохраняют один ключКаждое сохранение затирает поля другогоКлючом владеет один модуль
Два сервера держат одного игрокаСервер со старыми данными сохраняет последним и затирает новый прогрессБлокировка сессии

Блокировка сессии, «lock lost» и ProfileStore

Игрок подключён к одному серверу за раз, но финальное сохранение старого сервера может ещё идти, когда он заходит на новый: медленный повтор, телепорт или быстрый перезаход. Если новый сервер загрузит данные первым, у него окажутся старые данные, и победит тот сервер, который сохранит последним. Документация Roblox отмечает, что в играх с обменом этот промежуток частая причина дублирования предметов.

Блокировка сессии закрывает этот промежуток. Когда сервер загружает ключ игрока, он в том же вызове UpdateAsync записывает свой ID блокировки в метаданные ключа. Любой другой сервер, нашедший не истёкшую блокировку, которую ставил не он, не будет загружать и сохранять этот ключ. Владелец обновляет блокировку при каждом автосохранении и снимает её в финальном сохранении; если он перестаёт её обновлять, блокировка истекает, и её может забрать другой сервер.

Что значит «lock lost»

В системе с блокировкой сессии сервер потерял блокировку, когда ключом игрока теперь владеет другой сервер, потому что блокировка истекла или была перехвачена. Его копия может быть устаревшей, поэтому он должен перестать сохранять этого игрока; обычная реакция: кикнуть его с сообщением, чтобы он переподключился. Если вы увидели «lock lost» как игрок, это сообщение собственной системы сохранения той игры, и объяснить его могут только её разработчики.

Нужна ли она вам?

Модуль из этого гайда не блокирует сессии. Без блокировки реальный худший случай такой: в редкой гонке игрок теряет то, что заработал на старом сервере после его последнего успешного сохранения. Добавляйте блокировку, когда дублирование или потеря стоят игрокам чего-то настоящего: обмен, developer products, редкие предметы или частые телепорты.

ВариантЧто этоЧто стоит знать
Модуль из этого гайдаЗагрузка, кэш в памяти, повторы, автосохранение, сохранение при выключении и версии схемы, без блокировкиДостаточно короткий, чтобы прочитать целиком и изменить
Пример Roblox для данных игроков и покупокЭталонный код от Roblox с блокировкой сессии, повторами по порядку для каждого ключа и обработкой чеков покупокRoblox говорит, что он не проверен временем в популярной игре и не должен использоваться как есть без обширного тестирования
ProfileStoreБесплатный модуль сообщества с открытым кодом, преемник ProfileService, построенный вокруг блокировки сессии и автосохраненияНе от Roblox. Перевод существующей игры на него требует миграции уже сохранённых данных

Для любого стороннего модуля Roblox советует проверить, кто им владеет, поддерживается ли он и как вы доберётесь до своих данных без него. Та же документация называет DataStore2 устаревшей библиотекой, которую новым играм использовать не стоит.

Лимиты хранилищ данных

Это лимиты из документации Roblox на 30 сентября 2026 года. Roblox их пересматривает, поэтому проверьте страницу кодов ошибок и лимитов (на английском), прежде чем закладываться на точное число.

Лимиты запросов по умолчанию для каждого сервера, в минуту
Тип запросаОбычные хранилищаУпорядоченные хранилища
Чтение: GetAsync, чтение в UpdateAsync60 + 40 × игроков60 + 40 × игроков
Запись: SetAsync, IncrementAsync, запись в UpdateAsync60 + 40 × игроков30 + 5 × игроков
Список: ListKeysAsync или GetSortedAsync для упорядоченных хранилищ5 + 2 × игроков5 + 2 × игроков
Удаление: RemoveAsync60 + 40 × игроков30 + 5 × игроков

При 20 игроках сервер может делать 860 обычных записей в минуту; автосохранение этого модуля тратит около 7 из них, плюс одну на каждого вышедшего игрока. Бюджет исчерпывает сохранение при каждой подобранной монете. Второй бюджет действует на всю игру и делится с Open Cloud: 300 чтений в минуту плюс 40 на каждого игрока онлайн и 300 записей плюс 20 на игрока.

Лимиты размера и пропускной способности
ЛимитЗначение
Имя хранилища, имя ключа, scopeПо 50 символов
Значение в одном ключе4 194 304 символа в виде JSON
Чтение одного ключа со всех серверов25 МБ в минуту
Запись в один ключ со всех серверов4 МБ в минуту, каждый запрос округляется вверх до следующего КБ
Ожидающие запросы30 на очередь; сверх этого запросы падают с ошибками 301-306
Хранилище на всю игру500 МБ плюс 1 МБ на каждого пользователя за всё время

Размер данных игрока измеряйте через #HttpService:JSONEncode(data), а оставшийся бюджет живого сервера смотрите через DataStoreService:GetRequestBudgetForRequestType(Enum.DataStoreRequestType.StandardWrite). Вызовы GetAsync, на которые ответил 4-секундный кэш, не считаются. У режима Run в Studio свои, возможно более низкие лимиты, поэтому для проверки лимитов запросов Roblox советует Team Create.

Версии и резервные копии

Обычные хранилища данных хранят историю за вас. Первая запись в ключ в каждый час по UTC сохраняется как версия, а последующие записи в этот час перезаписывают друг друга. Старая версия истекает через 30 дней после того, как её заменила более новая запись; последняя не истекает никогда. Упорядоченные хранилища версий не хранят.

Чтобы откатить одного игрока, откройте Data Stores Manager (Creations, ваша игра, Configure > Data Stores Manager), выберите его ключ, выберите более раннюю версию и нажмите Revert; для этого нужно право Edit. Делайте это, пока игрок не в сети, иначе сервер с его сессией сохранит свою копию поверх отката. Из серверного скрипта ListVersionsAsync и GetVersionAsync находят и читают старую версию, которую вы затем записываете обратно как текущее значение.

Перед публикацией обновления, которое меняет способ сохранения данных, Roblox советует сделать снимок через Open Cloud Snapshot Data Stores API (один в день на игру). Без него ошибочное сохранение в 3:30 UTC затрёт всё, что было записано в этот ключ с 3:00, потому что оно попадает в ту же часовую версию.

Частые ошибки и решения

Ошибки хранилищ данных появляются в окне Output Studio, а модуль выводит предупреждение с текстом ошибки Roblox при каждой неудачной попытке. Гайд по ошибкам скриптов объясняет, как вообще читать Output.

StudioAccessToApisNotAllowed (ошибка 403)

«Can't write to DataStore from Studio because API access is not enabled.» Опубликуйте плейс, затем включите Enable Studio Access to API Services в File > Experience Settings > Security, в тестовой копии.

DataStore request was added to queue

Сервер отправляет запросы быстрее, чем позволяет бюджет, или слишком часто пишет один ключ, обычно из-за сохранения при каждом изменении или в цикле. Когда в очереди 30 запросов, новые падают с ошибками 301-306. Держите данные в памяти и сохраняйте по таймеру.

CantStoreValue (ошибка 104), или поле возвращается nil

В таблице есть то, что хранилище не умеет сохранять, например Instance, Vector3 или Color3. Сохраняйте вместо этого имя, ID или простые числа и восстанавливайте объект при загрузке.

ValueTooLarge (ошибка 105)

Один ключ хранит больше 4 194 304 символов JSON. Измерьте через #HttpService:JSONEncode(data), уберите то, что можно восстановить, или разделите данные на несколько постоянных ключей.

Ошибок нет, но данные не сохраняются

Поищите предупреждение модуля Could not load: после неудачной загрузки он намеренно отказывается сохранять. Иначе значение, скорее всего, менялось в LocalScript, а это никогда не доходит до сервера, или тот же ключ сохраняет другой скрипт.

Данные сбрасываются при каждом перезаходе

Ключ меняется между сессиями (собран из player.Name, или вы изменили STORE_NAME), загрузка не удаётся и вы видите значения по умолчанию, или модуль никто не подключает, и он вообще не работает. Проверьте Output и то, что Main подключает PlayerData.

Соберите это с RoCode

Если не хочется собирать это вручную, RoCode может сделать это прямо в открытом у вас плейсе. Это независимый ИИ-агент, не от Roblox, который работает через плагин для Roblox Studio: он пишет Luau, использующий DataStoreService как любой скрипт, и создаёт скрипты в вашем Explorer. Сам он никогда не обращается к вашим хранилищам данных, но с плагином 3.9 или новее может нажать Play для короткого плейтеста, где ваши скрипты работают как в любом тесте.

Вы пишете

Добавь сохранение в мою игру: храни Coins, Level и Inventory в модуле PlayerData с автосохранением и сохранением при выключении сервера и показывай Coins в leaderstats, которые у меня уже есть.

RoCode делает
  • Может поискать существующие leaderstats и код DataStore через Search Scripts и Read Script, чтобы расширить то, что у вас есть, а не добавлять второй скрипт сохранения. В большом плейсе назовите скрипт или папку в сообщении.
  • Создаёт ModuleScript и подключающий его Script через Create Script или меняет существующие через Edit Script
  • Запускает Check Script для каждого написанного скрипта: проверку компиляции внутри Studio с коротким списком предупреждений, а не проверку типов и не тестовый запуск
  • Отправляет изменения пакетами, и каждый пакет это точка отмены (undo) в Studio

Включать Studio Access to API Services в тестовой копии вам всё равно придётся самим: RoCode не может менять эту настройку. С плагином 3.9 или новее его короткий плейтест читает ошибки, а с плагином 3.9.11 или новее он может управлять тестовым персонажем, чтобы проверить, что игра работает, но проверяет он только то, что сам решил проверить, поэтому сыграйте сами и убедитесь, что Coins, Level и Inventory сохраняются и загружаются. Если сохранение не прошло в вашем тесте, Check Output может прочитать строки Server из запущенного вами плейтеста. Сохранение обычно добавляют, когда основной игровой цикл уже работает; создание игры Roblox с ИИ по одной системе за раз показывает этот порядок. Как RoCode подключается к Studio.

Частые вопросы

Как включить DataStore в Roblox Studio?

Опубликуйте плейс, откройте File > Experience Settings > Security, включите Enable Studio Access to API Services и нажмите Save. Делайте это в отдельной тестовой игре, потому что Studio тогда использует те же хранилища данных, что и живые серверы этой игры.

Сохраняет ли Roblox данные игрока автоматически?

Нет. Ничто об игроке не сохраняется после сессии, если серверный скрипт не сохранит это через DataStoreService, и leaderstats тоже.

Что выбрать: ProfileStore или DataStoreService напрямую?

ProfileStore тоже построен на хранилищах данных, поэтому вопрос в том, хотите ли вы, чтобы блокировку сессии написали и поддерживали за вас. Для обмена, платных предметов или частых телепортов блокировка стоит того, из библиотеки или эталонного примера Roblox. Для игры поменьше модуль вроде этого проще читать и менять.

Как сбросить или удалить данные игрока?

В Data Stores Manager найдите ключ и выберите Mark for Deletion, что можно отменить в течение периода ожидания, или вызовите RemoveAsync для ключа из серверного скрипта. Делайте это, пока игрок не в сети, иначе следующее сохранение его сервера запишет данные обратно. В тестовой копии смена STORE_NAME начинает всех с нуля; никогда не делайте этого в живой игре.

Источники и что почитать

Как проверялся код: каждый скрипт на этой странице проходит строгую проверку типов Luau с определениями Roblox API (luau-lsp, 12 ноября 2026 г.). Проверка типов ловит опечатки в API и неверные типы, но не ошибки игровой логики, поэтому протестируйте всё в Studio перед публикацией.

Попробуйте RoCode в своей игре.

Бесплатные кредиты каждый день, без карты. Установите плагин, опишите функцию и проверьте, что появилось в Studio.