Storage

local CONCURRENT_KEY = script:GetCustomProperty("ConcurrentKey")
local SEND_PERIOD = script:GetCustomProperty("SendPeriod") or 10

-- Add players when they join. Subtract when they leave.
local deltaPlayers = 0

local function OnPlayerJoined(player)
    deltaPlayers = deltaPlayers + 1
end

local function OnPlayerLeft(player)
    deltaPlayers = deltaPlayers - 1
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)
Game.playerLeftEvent:Connect(OnPlayerLeft)

function Tick()
    Task.Wait(SEND_PERIOD)

    -- Nothing has changed. Try again later
    if deltaPlayers == 0 then return end

    -- There's already a Set operation in progress. Try again later
    if Storage.HasPendingSetConcurrentCreatorData(CONCURRENT_KEY) then return end

    -- Apply the difference in total players
    local data, result, message = Storage.SetConcurrentCreatorData(CONCURRENT_KEY, function(data)
        if not data.totalPlayers then
            data.totalPlayers = deltaPlayers
        else
            data.totalPlayers = data.totalPlayers + deltaPlayers
        end
        return data
    end)
    deltaPlayers = 0

    -- Possible error message
    if result ~= StorageResultCode.SUCCESS then
        warn("Failed to set total players. Result code = " ..result ..", "..tostring(message))
    end
end

-- Listen for changes to the data and update the `totalPlayers` variable.
local totalPlayers = 0

function OnConcurrentDataChanged(_, data)
    if data.totalPlayers and data.totalPlayers ~= totalPlayers then
        totalPlayers = data.totalPlayers
        -- Tell everyone about the new total players across all games
        Chat.BroadcastMessage("Total players: " .. totalPlayers)
    end
end
Storage.ConnectToConcurrentCreatorDataChanged(CONCURRENT_KEY, OnConcurrentDataChanged)

-- When this server instance comes online, fetch the latest data right away
local data, result, message = Storage.GetConcurrentCreatorData(CONCURRENT_KEY)
if result == StorageResultCode.SUCCESS then
    OnConcurrentDataChanged(_, data)
else
    warn("Initial get of total players failed.")
end

local NEW_MESSAGE_EVENT_ID = "NewMessage"

local pendingIds = {}
local pendingMessages = {}

-- This function can be called to send any message to a player, even if they are not in the game
function SendToPlayer(playerId, message)
    table.insert(pendingIds, playerId)
    table.insert(pendingMessages, message)
end

function Tick()
    -- This Tick() will usually do nothing, until there is a new message waiting to be sent
    if #pendingIds > 0 then
        local playerId = pendingIds[1]
        local message = pendingMessages[1]

        -- In case concurrent storage is busy for this player, exit and try again later
        if Storage.HasPendingSetConcurrentPlayerData(playerId) then return end

        -- Moving ahead with the attempt to send message. Remove it from the pending queue
        table.remove(pendingIds, 1)
        table.remove(pendingMessages, 1)

        -- Try to put the message into the player's inbox
        local data, result, message = Storage.SetConcurrentPlayerData(playerId, function(data)
            if not data.inbox then
                data.inbox = {}
            end
            table.insert(data.inbox, message)
            return data
        end)

        if result == StorageResultCode.EXCEEDED_SIZE_LIMIT then
            warn("Inbox full for player " .. playerId)
        end
    end
end

-- Requests the latest concurrent storage data for a player
function CheckInbox(player)
    local playerId = player.id
    local data, result, message = Storage.GetConcurrentPlayerData(playerId)
    if result == StorageResultCode.SUCCESS then
        NotifyInbox(player, data.inbox)
    else
        warn("Failed to get inbox for player " .. playerId .. ". Result code: " .. result)
    end
end

-- Called when the server detects changes to a player's concurrent data
function OnConcurrentPlayerDataChanged(playerId, data)
    -- Find the actual player object based on their ID
    local player = Game.FindPlayer(playerId)
    NotifyInbox(player, data.inbox)
end

function NotifyInbox(player, inbox)
    -- Send the messages to the player's Client. They could be displayed in the UI
    -- At this point no messages are removed from their inbox
    if Object.IsValid(player) and inbox ~= nil then
        for _,message in ipairs(inbox) do
            Events.BroadcastToPlayer(player, NEW_MESSAGE_EVENT_ID, message)
        end
    end
end

local playerStorageListeners = {}

local function OnPlayerJoined(player)
    -- Only the server in which a player has joined listens for new messages in their inbox
    local listener = Storage.ConnectToConcurrentPlayerDataChanged(player.id, OnConcurrentPlayerDataChanged)
    -- Save the event listener so we can disconnect from it later
    playerStorageListeners[player] = listener
    Task.Wait(3)
    -- After the player joins, check their inbox
    if Object.IsValid(player) then
        CheckInbox(player)
    end
end

local function OnPlayerLeft(player)
    -- The player is leaving. Disconnect the event listener to stop receiving message events on this server
    if playerStorageListeners[player].isConnected then
        playerStorageListeners[player]:Disconnect()
        playerStorageListeners[player] = nil
    end
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)
Game.playerLeftEvent:Connect(OnPlayerLeft)

local STORAGE_KEY = script:GetCustomProperty("StorageKey")

function OnPlayerJoined(player)
    -- Do as much work as possible outside of the callback, to minimize duration of lock
    local sceneName = Game.GetCurrentSceneName()
    local timestamp = DateTime.CurrentTime():ToIsoString()
    local lastSeenData = {
        sceneName = sceneName,
        timestamp = timestamp
    }
    Storage.SetConcurrentSharedPlayerData(STORAGE_KEY, player.id, function(data)
        data.lastSeen = lastSeenData
        return data
    end)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

function GetLastSeen(playerId)
    local data, result = Storage.GetConcurrentSharedPlayerData(STORAGE_KEY, playerId)
    if result == StorageResultCode.SUCCESS then
        return data.lastSeen
    end
    return nil
end

local LEADERBOARD_REF = script:GetCustomProperty("LeaderboardRef")
local STORAGE_KEY = script:GetCustomProperty("StorageKey")

-- Wait for leaderboards to load.
-- If a score has never been submitted it will stay in this loop forever
while not Leaderboards.HasLeaderboards() do
    Task.Wait(1)
end

local leaderboard = Leaderboards.GetLeaderboard(LEADERBOARD_REF, LeaderboardType.GLOBAL)
for i, entry in ipairs(leaderboard) do
    local playerId = entry.id
    local player = Game.FindPlayer(playerId)
    local data
    if player then
        -- The player is on this server, access data directly
        if STORAGE_KEY and STORAGE_KEY.isAssigned then
            -- If there is a shared game key
            data = Storage.GetSharedPlayerData(STORAGE_KEY, player) -- method 1
        else
            data = Storage.GetPlayerData(player) -- method 2
        end
    else
        -- Player is not here, use offline storage. This yields the thread
        if STORAGE_KEY and STORAGE_KEY.isAssigned then
            -- If there is a shared game key
            data = Storage.GetSharedOfflinePlayerData(STORAGE_KEY, playerId) -- method 3
        else
            data = Storage.GetOfflinePlayerData(playerId) -- method 4
        end
    end
    -- Get the additional data
    local playerLevel = data["level"] or 0

    print(i .. ")", entry.name, ":", entry.score, "- Level " .. playerLevel)
end

function OnPlayerJoined(player)
    local data = Storage.GetPlayerData(player)
    -- In case it's the first time for this player we use default values 0 and 1
    local xp = data["xp"] or 0
    local level = data["level"] or 1
    -- Each time they join they gain 1 XP. Stop and play the game again to test that this value keeps going up
    xp = xp + 1
    player:SetResource("xp", xp)
    player:SetResource("level", level)
    print("Player " .. player.name .. " joined with Level " .. level .. " and XP " .. xp)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

local propSharedKey = script:GetCustomProperty("DocTestSharedKey")
local returnTable = Storage.GetSharedPlayerData(propSharedKey, player)

-- Print out the data we retrieved:
for k, v in pairs(returnTable) do
    print(k, v)
end

function OnResourceChanged(player, resName, resValue)
    if (resName == "xp" or resName == "level") then
        local data = Storage.GetPlayerData(player)
        data[resName] = resValue
        local resultCode,errorMessage = Storage.SetPlayerData(player, data)
    end
end

function OnPlayerJoined(player)
    player.resourceChangedEvent:Connect(OnResourceChanged)
end

Game.playerJoinedEvent:Connect(OnPlayerJoined)

local propSharedKey = script:GetCustomProperty("DocTestSharedKey")

local sampleData = {
    name = "Philip",
    points = 1000,
    favorite_color = Color.RED,
    skill_levels = {swordplay = 8, flying = 10, electromagnetism = 5, friendship = 30}
}
Storage.SetSharedPlayerData(propSharedKey, player, sampleData)

-- Server Script
-- Enable player storage

local function OnPlayerLeft(player)
local data = Storage.GetPlayerData(player)

data.coins = 1000
data.petName = "Frodo"
data.items = {1, 2, 3, 4, 5, 6, 7, 8, 9}

print(Storage.SizeOfData(data)) -- 192
print(Storage.SizeOfCompressedData(data)) -- 152

Storage.SetPlayerData(data)
end

Game.playerLeftEvent:Connect(OnPlayerLeft)