Zdobywanie punktów

W poprzednich samouczkach stworzyłeś różnorodne funkcje doświadczenia, w tym znikające platformy oraz śmiertelną lawę. Ten samouczek łączy te elementy w grywalne doświadczenie, w którym użytkownicy będą mogli sprawdzić, kto najdłużej będzie w stanie przetrwać. Każda sekunda, w której pozostaną przy życiu, doda punkt do ich wyniku.

Ustawienia

Na początku musisz ustawić scenę dla swojego doświadczenia. Skopiuj znikające platformy, które stworzyłeś w poprzednim samouczku, i pozwól użytkownikom rywalizować o to, kto będzie mógł jak najdłużej pozostać na platformach.

Możesz również użyć śmiertelnej lawy, aby zabić użytkowników, gdy spadną z platform, lub po prostu pozwolić im spaść na zgubę. Upewnij się, że umieszczasz SpawnLocation w miejscu, z którego użytkownicy mogą skakać na platformy, aby rozpocząć grę.

Punkty gracza

Roblox ma wbudowaną Tablicę wyników do pokazania statystyk użytkowników. Gdy ustawisz punkty gracza poprzez tablicę wyników, pojawią się one po prawej stronie ekranu w doświadczeniu.

W kolejnych samouczkach nauczysz się bardziej konfigurowalnych sposobów wyświetlania informacji, ale tablica wyników jest najprostszym sposobem na stworzenie widocznego systemu punktacji w Robloxie.

Najlepiej umieścić skrypty, które ustalają stan doświadczenia, w ServerScriptService, ponieważ będą one automatycznie uruchamiane, gdy doświadczenie się rozpocznie. W ServerScriptService stwórz skrypt o nazwie SetupPoints.

Słuchaj graczy

W Robloxie serwis to obiekt, który wykonuje szereg przydatnych funkcji. Serwis Players ma zdarzenie o nazwie PlayerAdded, które możesz wykorzystać do ustawienia punktów dla każdego użytkownika, który dołącza do doświadczenia.

Możesz uzyskać dostęp do serwisów za pomocą funkcji GetService w obiekcie game. game to zmienna dostępna z dowolnego miejsca, która zawiera wszystko w twoim doświadczeniu.

1. Utwórz zmienną dla serwisu Players używając game:GetService("Players").

2. Utwórz funkcję o nazwie onPlayerAdded z parametrem dla nadchodzącego gracza.

3. Podłącz funkcję onPlayerAdded do zdarzenia PlayerAdded.

   local Players = game:GetService("Players")
   
   local function onPlayerAdded(player)
   
   end
   
   Players.PlayerAdded:Connect(onPlayerAdded)

Utwórz folder statystyk

Aby punkty użytkownika były wyświetlane na tablicy wyników, wystarczy utworzyć nowy Folder w obiekcie Player o nazwie "leaderstats" i umieścić tam ich punkty. Nowe obiekty można tworzyć z poziomu skryptu za pomocą funkcji Instance.new().

1. Utwórz nowy obiekt Folder używając Instance.new("Folder"), przechowując wynik w nowej zmiennej o nazwie leaderstats.

   local function onPlayerAdded(player)
   	local leaderstats = Instance.new("Folder")
   end

2. Ustaw właściwość Name leaderstats na "leaderstats".

3. Rodzicem leaderstats uczyn player.

   local Players = game:GetService("Players")
   
   local function onPlayerAdded(player)
   	local leaderstats = Instance.new("Folder")
      leaderstats.Name = "leaderstats"
      leaderstats.Parent = player
   end
   
   Players.PlayerAdded:Connect(onPlayerAdded)

Utwórz punkty

System tablicy wyników odczytuje wszelkie wartości w folderze leaderstats i wyświetla to, co znajdzie.

Aby dodać statystykę, która będzie śledzić punkty gracza, nowy obiekt IntValue można rodzicem uczynić folderu leaderstats. Nazwa obiektu wartości będzie wyświetlana obok jej aktualnej wartości.

1. Użyj zmiennej o nazwie points, aby utworzyć nowy obiekt IntValue przy użyciu Instance.new().
2. Ustaw Name na "Points".
3. Ustaw Value na 0; to jest to, co tablica wyników początkowo wyświetli dla gracza.
4. Uczyń obiekt points rodzicem folderu leaderstats.

local Players = game:GetService("Players")

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats
end

Players.PlayerAdded:Connect(onPlayerAdded)

Przetestuj swoje doświadczenie, a powinieneś zobaczyć tablicę wyników pojawiającą się w prawym górnym rogu z nazwami użytkowników i punktami obok nich.

Licz czas

Każdy użytkownik powinien zdobywać punkt za każdą sekundę, w której żyje. Pętla while i funkcja task.wait() mogą być użyte do aktualizacji wartości punktów co sekundę.

1. Na końcu skryptu utwórz pętlę while z true jako warunkiem.
2. W pętli, task.wait() na 1 sekundę.

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
end

Lista graczy

Aby uruchomić kod dla każdego użytkownika w doświadczeniu, musisz iterować przez tablicę użytkowników zwróconą przez funkcję GetPlayers.

Tablica to lista elementów przechowywanych w kolejności. Każdy element można uzyskać za pomocą jego indeksu, zaczynając od 1. Możesz uzyskać długość tablicy, poprzedzając ją #.

1. Przechowaj wynik Players:GetPlayers() w zmiennej playerList.
2. Utwórz pętlę for z wartością początkową 1 i wartością końcową #playerList, aby uzyskać jedną iterację pętli dla każdego gracza.

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    -- Dodaj swoją logikę tutaj dla każdego gracza w playerList
  end
end

Przyznawaj punkty

Aby przyznać punkt każdemu użytkownikowi w pętli for, musisz wydobyć użytkownika z tablicy i dodać 1 do obiektu Points przechowywanego w ich folderze leaderstats.

Obiekty przechowywane w tablicy są dostępne za pomocą kwadratowych nawiasów - na przykład, pierwszy element w tablicy playerList można uzyskać za pomocą playerList[1]. Jeśli w pętli for napiszesz playerList[currentPlayer], możesz przechodzić przez każdego użytkownika w liście z każdą iteracją pętli.

1. Przechowaj użytkownika z playerList[currentPlayer] w zmiennej o nazwie player.
2. Przechowaj obiekt Points użytkownika w zmiennej o nazwie points.
3. Ustaw właściwość Value dla points na points.Value + 1.

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]
    local points = player.leaderstats.Points
    points.Value += 1
  end
end

Przetestuj swoje doświadczenie, a powinieneś zauważyć, że tablica wyników zlicza punkty twojego gracza, podnosząc je o 1 co sekundę.

Słuchaj postaci

Celem doświadczenia jest zobaczenie, kto może przetrwać najdłużej, więc użytkownicy, którzy umrą, będą musieli mieć swoje punkty zresetowane do 0.

Musisz uzyskać model Character dla użytkownika, aby wykryć, kiedy umarł. Ten model jest dodawany do doświadczenia po załadowaniu obiektu Player, a zdarzenie CharacterAdded możesz użyć do nasłuchiwania, kiedy postać jest gotowa do użycia. Stwórz funkcję o nazwie onCharacterAdded, mającą dwa parametry: jeden dla postaci, a drugi dla gracza.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)

end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")

Mimo że dołączyłeś użytkownika do parametrów funkcji onCharacterAdded, zdarzenie CharacterAdded zwraca tylko postać, a nie powiązanego użytkownika. Aby również przekazać obiekt player, użyj funkcji anonimowej do połączenia ze zdarzeniem.

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Resetuj punkty

Gdy użytkownik umiera, jego Humanoid automatycznie uruchamia zdarzenie Died. Możesz użyć tego zdarzenia, aby dowiedzieć się, kiedy zresetować jego punkty.

Humanoid znajduje się w modelu postaci, ale zawartość tego modelu jest zestawiana tylko gdy użytkownik się odrodzi. Aby twoj kod mógł bezpiecznie poczekać na załadowanie obiektu Humanoid, użyj funkcji WaitForChild(). Możesz ją wywołać na dowolnym obiekcie nadrzędnym, przekazując nazwę łańcucha dziecka, na które czekasz. Utwórz zmienną, aby poczekać na Humanoid, używając character:WaitForChild("Humanoid").

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")
end

Funkcja, którą musisz podłączyć do zdarzenia Died, jest bardzo krótka i będzie potrzebna tylko tutaj, więc możesz ponownie użyć funkcji anonimowej.

1. Podłącz nową funkcję anonimową do zdarzenia Died Humanoida.
2. W funkcji anonimowej utwórz zmienną o nazwie points dla obiektu Points gracza.
3. Ustaw właściwość Value dla points na 0.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
  end)
end

Przetestuj to, a zobaczysz, że wynik użytkownika resetuje się, gdy umiera.

Sprawdź gracza

Jeśli użytkownicy nadal zdobywają punkty nawet po śmierci, z pewnością nie jest to w duchu doświadczenia, więc kod musi sprawdzać, czy użytkownicy żyją, zanim przyzna punkt.

Musisz zacząć od zdefiniowania atrybutu w funkcji onPlayerAdded, który można wykorzystać do sprawdzenia, czy użytkownik jest żywy. Na tym etapie użytkownik jeszcze nie żyje i nie jest odrodzony, ponieważ model postaci jeszcze nie został dodany.

Atrybuty pozwalają na dostosowywanie obiektów w Robloxie za pomocą własnych danych. Atrybut składa się z nazwy i wartości. Możesz utworzyć atrybut na dowolnym obiekcie, używając funkcji SetAttribute. Wywołaj SetAttribute na player, aby utworzyć nowy atrybut o nazwie "IsAlive" z wartością false.

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Gdy model postaci użytkownika zostanie odrodzony, wartość IsAlive musi zostać zmieniona na true, aby użytkownik mógł zaczynać znowu zdobywać punkty.

1. W onCharacterAdded, ustaw atrybut IsAlive player na true.
2. W onCharacterDied, ustaw atrybut IsAlive player na false.

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)

  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

Na końcu, atrybut IsAlive powinien być sprawdzany przed przyznaniem punktu w pętli while na końcu skryptu. Funkcja GetAttribute przyjmuje nazwę atrybutu i zwraca wartość. W pętli while, opakuj kod do przyznawania punktu w instrukcję if z warunkiem player:GetAttribute("IsAlive").

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()

  for currentPlayer = 1, #playerList do
    local player = playerList[currentPlayer]

    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end

Teraz przetestuj swoje doświadczenie, a powinieneś zobaczyć, że użytkownik zdobywa punkty co sekundę, w której jest żywy, a zamienia się na 0, gdy nie żyje. Pozwól swoim znajomym zagrać z tobą i zobacz, kto zdobędzie najwyższy wynik.

To dopiero początek: możesz kontynuować ulepszanie swojego doświadczenia dla użytkowników. Oto kilka wskazówek:

• Umieść kod dla wszystkich platform w jednym skrypcie, co znacznie ułatwi aktualizację.
• Stwórz strefę lobby, w której użytkownicy będą czekać na teleportację do obszaru doświadczenia, co pozwoli na równoczesne rozpoczęcie przez wszystkich użytkowników.
• Ogłoś zwycięzców każdej rundy.

Finalny kod

local Players = game:GetService("Players")

local function onCharacterAdded(character, player)
  player:SetAttribute("IsAlive", true)
  local humanoid = character:WaitForChild("Humanoid")

  humanoid.Died:Connect(function()
    local points = player.leaderstats.Points
    points.Value = 0
    player:SetAttribute("IsAlive", false)
  end)
end

local function onPlayerAdded(player)
  local leaderstats = Instance.new("Folder")
  leaderstats.Name = "leaderstats"
  leaderstats.Parent = player

  local points = Instance.new("IntValue")
  points.Name = "Points"
  points.Value = 0
  points.Parent = leaderstats

  player:SetAttribute("IsAlive", false)

  player.CharacterAdded:Connect(function(character)
    onCharacterAdded(character, player)
  end)
end

Players.PlayerAdded:Connect(onPlayerAdded)

while true do
  task.wait(1)
  local playerList = Players:GetPlayers()
  for i = 1, #playerList do
    local player = playerList[i]
    if player:GetAttribute("IsAlive") then
      local points = player.leaderstats.Points
      points.Value += 1
    end
  end
end