Rejestracja i wyświetlanie danych gracza | Dokumentacja

Teraz, gdy potrafisz wykryć, kiedy gracz zebrał monetę, musisz zliczyć, ile monet gracze zebrali i uczynić tę wartość widoczną na tablicy wyników.

Utwórz skrypt modułowy do rejestrowania zbierania monet

Aby obsługiwać przechowywanie i zarządzanie danymi o zbiorze monet każdego gracza, musisz stworzyć obiekt ModuleScript, który będzie zawierał strukturę danych oraz funkcje, które uzyskują dostęp do danych o zbieraniu monet dla każdego gracza. Skrypty modułowe to kod, który można wielokrotnie wykorzystywać, a inne skrypty mogą go wymagać. W tym przypadku CoinService wymaga tego skryptu modułowego, aby móc aktualizować dane o zbieraniu monet, gdy gracze dotykają monet.

Utwórz PlayerData
W ServerStorage utwórz ModuleScript o nazwie PlayerData z następującym kodem:

```lua
local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
      ["Coins"] = coinAmount: number
    }
  ]]
}

local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

function PlayerData.getValue(player, key)
  return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

return PlayerData
```

Wyjaśnienie kodu

Skrypt modułowy definiuje tabelę PlayerData, która zawiera zera lub więcej tabel playerData, które reprezentują dane o zbieraniu monet dla gracza. Każdy skrypt, który wymaga tego skryptu modułowego, otrzymuje tę samą kopię tabeli PlayerData, co pozwala wielu skryptom na modyfikowanie i dzielenie się danymi o zbieraniu monet.

Zadeklaruj struktury danych

Skrypt modułowy zaczyna się od deklaracji pustej tabeli PlayerData, która jest zwracana na końcu skryptu. Zawiera również metody dostępu do pobierania i ustawiania wartości w tabeli.

Tabela playerData zawiera komentarze, które opisują strukturę tabeli, co ułatwia zrozumienie kodu. W tym przypadku tabela playerData zawiera userId oraz odpowiadające pole o nazwie Coins, które reprezentuje ilość zebranych monet dla danego gracza.


local PlayerData = {}
PlayerData.COIN_KEY_NAME = "Coins"

local playerData = {
  --[[
    [userId: string] = {
        ["Coins"] = coinAmount: number
    }
  ]]
}

...

return PlayerData

Zdefiniuj lokalny dostęp do danych

getData() to lokalna funkcja, która pobiera dane dla konkretnej tabeli playerData. Jeśli gracz nie zebrał jeszcze monety, zwraca tabelę z funkcji defaultPlayerData(), aby upewnić się, że każdy gracz ma przypisane jakieś dane. Powszechną konwencją jest tworzenie prostych funkcji publicznych, które przekazują logikę do funkcji o lokalnym zakresie, które wykonują większą część pracy.


local function defaultPlayerData()
  return {
    [PlayerData.COIN_KEY_NAME] = 0
  }
end

local function getData(player)
  local data = playerData[tostring(player.UserId)] or defaultPlayerData()
  playerData[tostring(player.UserId)] = data
  return data
end

Zdefiniuj publiczne dostęp do danych

getValue() i updateValue() to funkcje publiczne, które mogą być wywoływane przez inne skrypty, które wymagają tego skryptu modułowego. W naszym przypadku CoinService używa tych funkcji do aktualizacji danych o zbieraniu monet gracza za każdym razem, gdy ten gracz dotyka monety.


function PlayerData.getValue(player, key)
 return getData(player)[key]
end

function PlayerData.updateValue(player, key, updateFunction)
  local data = getData(player)
  local oldValue = data[key]
  local newValue = updateFunction(oldValue)

  data[key] = newValue
  return newValue
end

Zaimplementuj tablicę wyników

Możesz wizualnie przedstawić dane o zbieraniu monet na ekranie za pomocą tablicy wyników. Roblox zawiera wbudowany system, który automatycznie generuje tablicę wyników, korzystając z domyślnego interfejsu UI.

Utwórz Tablicę Wyników
W ServerStorage utwórz ModuleScript o nazwie Leaderboard z następującym kodem:

```lua
local Leaderboard = {}

-- Tworzenie nowej tablicy wyników
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' to zarezerwowana nazwa, którą Roblox rozpoznaje jako tworzenie tablicy wyników
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Tworzenie nowej wartości statystyki w tablicy wyników
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

-- Aktualizowanie wartości statystyki gracza
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

return Leaderboard
```

Wyjaśnienie kodu

Następujące sekcje opisują, jak działa tablica wyników w większych szczegółach.

Utwórz tablicę wyników

Funkcja setupLeaderboard() tworzy nową instancję folderu o nazwie leaderstats i ustawia ją jako dziecko określonego gracza. Roblox automatycznie rozpoznaje folder o nazwie leaderstats jako kontener statystyk i tworzy element UI do wyświetlania tych statystyk. Wymaga, aby wartości w leaderstats były przechowywane jako obiekty "value" (takie jak StringValue, IntValue lub NumberValue).


-- Tworzenie nowej tablicy wyników
local function setupLeaderboard(player)
  local leaderstats = Instance.new("Folder")
  -- 'leaderstats' to zarezerwowana nazwa, którą Roblox rozpoznaje jako tworzenie tablicy wyników
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player
  return leaderstats
end

-- Tworzenie nowej wartości statystyki w tablicy wyników
local function setupStat(leaderstats, statName)
  local stat = Instance.new("IntValue")
  stat.Name = statName
  stat.Value = 0
  stat.Parent = leaderstats
  return stat
end

Aktualizacja statystyk graczy

setStat() to jedyna publiczna funkcja w module Leaderboard. Tworzy wartości statystyk dla określonego gracza lub samej tablicy wyników, jeśli jeszcze nie istnieje.

FindFirstChild() przyjmuje nazwę obiektu i zwraca ten obiekt, jeśli istnieje, lub nil, jeśli go nie ma. To powszechnie stosowana, bezpieczna metoda, aby sprawdzić, czy obiekt istnieje przed jego użyciem.


-- Aktualizowanie wartości statystyki gracza
function Leaderboard.setStat(player, statName, value)
  local leaderstats = player:FindFirstChild("leaderstats")
  if not leaderstats then
    leaderstats = setupLeaderboard(player)
  end

  local stat = leaderstats:FindFirstChild(statName)
  if not stat then
    stat = setupStat(leaderstats, statName)
  end

  stat.Value = value
end

Zintegruj skrypty modułowe

Mając oba moduły w miejscu, załaduj je w skrypcie CoinService, aby zarządzać i wyświetlać dane monet gracza.

Aktualizuj CoinService
W ServerScriptService zamień istniejący kod skryptu CoinService na następujący:

```lua
-- Inicjalizacja usług i zmiennych
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerStorage = game:GetService("ServerStorage")

-- Moduły
local Leaderboard = require(ServerStorage.Leaderboard)
local PlayerData = require(ServerStorage.PlayerData)

local coinsFolder = Workspace.World.Coins
local coins = coinsFolder:GetChildren()

local COIN_KEY_NAME = PlayerData.COIN_KEY_NAME
local COOLDOWN = 10
local COIN_AMOUNT_TO_ADD = 1

local function updatePlayerCoins(player, updateFunction)
  -- Aktualizacja tabeli monet
  local newCoinAmount = PlayerData.updateValue(player, COIN_KEY_NAME, updateFunction)

  -- Aktualizacja tablicy wyników monet
  Leaderboard.setStat(player, COIN_KEY_NAME, newCoinAmount)
end

-- Definiowanie obsługi zdarzenia
local function onCoinTouched(otherPart, coin)
  if coin:GetAttribute("Enabled") then
    local character = otherPart.Parent
    local player = Players:GetPlayerFromCharacter(character)
    if player then
      -- Gracz dotknął monety
      coin.Transparency = 1
      coin:SetAttribute("Enabled", false)
      updatePlayerCoins(player, function(oldCoinAmount)
        oldCoinAmount = oldCoinAmount or 0
        return oldCoinAmount + COIN_AMOUNT_TO_ADD
      end)

      task.wait(COOLDOWN)
      coin.Transparency = 0
      coin:SetAttribute("Enabled", true)
    end
  end
end

-- Ustawianie nasłuchów zdarzeń
for _, coin in coins do
  coin:SetAttribute("Enabled", true)
  coin.Touched:Connect(function(otherPart)
    onCoinTouched(otherPart, coin)
  end)
end
```

Wyjaśnienie kodu

Zmiany w oryginalnym skrypcie CoinService obejmują:

Importowanie modułów PlayerData i Leaderboard za pomocą funkcji require().
Zadeklarowanie COIN_AMOUNT_TO_ADD jako liczby monet, które mają zostać dodane, gdy gracz zbiera monetę, oraz COIN_KEY_NAME jako nazwy klucza zdefiniowanej w PlayerData.
Utworzenie funkcji pomocniczej updatePlayerCoins(), aby zaktualizować licznik monet gracza oraz związaną z nim statystykę w tablicy wyników.
Zastąpienie miejsca na instrukcję print() w onCoinTouched() wywołaniem updatePlayerCoins().

Testowanie

Wybierz Test z rozwijanego menu i kliknij Play. Wejdź w monetę i potwierdź, że tablica wyników pojawia się w rogu oraz że liczba Twoich monet zwiększa się, gdy zbierasz więcej monet.