Podstawy Skryptowania Lua w Roblox Studio

Podstawy Skryptowania Lua w Roblox Studio

Przewodnik dla początkujących

Wprowadzenie

Lua to język skryptowy używany w Roblox do tworzenia gier. Skrypty pozwalają dodawać logikę, interakcje i dynamiczne elementy do Twojego świata w Roblox.

Skrypty umieszcza się w różnych miejscach w Explorerze Roblox Studio, najczęściej w ServerScriptService (dla logiki serwera) lub wewnątrz obiektów (np. Part) jako Script lub LocalScript (dla logiki klienta).

Zmienne (Variables)

Zmienne służą do przechowywania danych. W Lua tworzysz zmienną, podając jej nazwę i przypisując wartość.


-- Tworzenie zmiennej lokalnej (zalecane)
local playerName = "Gracz123"
local score = 100
local canJump = true

-- Zmiana wartości zmiennej
score = score + 10 -- Teraz score wynosi 110

-- Wypisanie wartości zmiennej w Output
print(playerName)
print(score)

Typy Danych (Data Types)

Lua posiada kilka podstawowych typów danych:

string: Tekst, np. "Witaj świecie!"
number: Liczby (całkowite i zmiennoprzecinkowe), np. 10, 3.14
boolean: Wartości logiczne: true (prawda) lub false (fałsz)
nil: Reprezentuje brak wartości.
table: Struktura danych do przechowywania kolekcji wartości (podobne do tablic lub słowników).
Instance: Specyficzny dla Roblox typ reprezentujący obiekty w grze (np. Part, Model, Script).
function: Blok kodu, który można wielokrotnie wywoływać.


local message = "To jest tekst" -- string
local health = 100           -- number
local isAlive = true         -- boolean
local target = nil           -- nil (np. gdy gracz nie ma celu)
local items = {"miecz", "tarcza"} -- table (tablica)
local playerStats = {        -- table (słownik)
  Name = "SuperGracz",
  Level = 5
}

print(type(message)) -- Wypisze: string
print(type(health))  -- Wypisze: number
print(type(items))   -- Wypisze: table

Operatory (Operators)

Arytmetyczne: + (dodawanie), - (odejmowanie), * (mnożenie), / (dzielenie), % (modulo - reszta z dzielenia), ^ (potęgowanie)
Relacyjne: == (równe), ~= (różne od), < (mniejsze niż), > (większe niż), <= (mniejsze lub równe), >= (większe lub równe)
Logiczne: and (i), or (lub), not (negacja)


local a = 10
local b = 5

print(a + b)  -- 15
print(a > b)  -- true
print(a == 10 and b == 5) -- true
print(not (a ~= 10)) -- true (bo a JEST równe 10, negacja fałszu to prawda)

Instrukcje Warunkowe (Conditional Statements)

Pozwalają wykonywać kod tylko wtedy, gdy spełniony jest określony warunek.


local playerHealth = 50

if playerHealth <= 0 then
  print("Gracz nie żyje!")
elseif playerHealth < 50 then
  print("Gracz ma mało zdrowia!")
else
  print("Gracz ma wystarczająco zdrowia.")
end -- Zawsze kończymy 'if' słowem 'end'

Pętle (Loops)

Pozwalają powtarzać wykonanie bloku kodu.


-- Pętla 'for' (liczbowa)
print("Liczenie do 3:")
for i = 1, 3, 1 do -- Od 1 do 3, krok co 1
  print(i)
end

-- Pętla 'for' (generyczna, do iteracji po tabelach)
local fruits = {"jabłko", "banan", "pomarańcza"}
print("Owoce:")
for index, fruit in ipairs(fruits) do -- ipairs dla tablic indeksowanych numerycznie
  print(index, fruit)
end

local playerInfo = { Name = "Test", Score = 150 }
print("Informacje o graczu:")
for key, value in pairs(playerInfo) do -- pairs dla słowników (klucz-wartość)
  print(key, ":", value)
end

-- Pętla 'while' (dopóki warunek jest prawdziwy)
local counter = 5
print("Odliczanie while:")
while counter > 0 do
  print(counter)
  counter = counter - 1 -- Ważne: zmiana warunku, aby uniknąć pętli nieskończonej
end

-- Pętla 'repeat until' (wykonuje się co najmniej raz, dopóki warunek nie stanie się prawdziwy)
local attempts = 0
print("Próby repeat:")
repeat
  attempts = attempts + 1
  print("Próba numer:", attempts)
until attempts >= 3 -- Warunek sprawdzany na końcu

Funkcje (Functions)

Bloki kodu, które można nazwać i wywoływać wielokrotnie, często z parametrami (danymi wejściowymi).


-- Definicja funkcji
local function greetPlayer(name)
  print("Witaj, " .. name .. "!") -- '..' służy do łączenia tekstów (konkatenacji)
end

-- Wywołanie funkcji
greetPlayer("NowyGracz")
greetPlayer("MistrzLua")

-- Funkcja zwracająca wartość
local function addNumbers(num1, num2)
  local sum = num1 + num2
  return sum -- Zwraca wynik dodawania
end

local result = addNumbers(5, 7)
print("Wynik dodawania:", result) -- Wypisze: Wynik dodawania: 12

Zdarzenia (Events)

W Roblox wiele obiektów ma zdarzenia, które "odpalają się", gdy coś się stanie (np. dotknięcie części, kliknięcie przycisku). Możemy podłączyć funkcje do tych zdarzeń.


-- Przykład: Skrypt wewnątrz części (Part) w Workspace
local part = script.Parent -- Zakładamy, że skrypt jest dzieckiem części

local function onPartTouched(otherPart)
  -- 'otherPart' to część, która dotknęła naszej części
  print(part.Name .. " został dotknięty przez " .. otherPart.Name)

  -- Sprawdzenie, czy dotykająca część należy do postaci gracza
  local humanoid = otherPart.Parent:FindFirstChild("Humanoid")
  if humanoid then
    print("Dotknięty przez gracza!")
    -- Tutaj można dodać logikę, np. zadawanie obrażeń
    -- humanoid:TakeDamage(10)
  end
end

-- Podłączenie funkcji 'onPartTouched' do zdarzenia 'Touched'
part.Touched:Connect(onPartTouched)

-- Przykład dla ClickDetector (umieszczonego wewnątrz części)
local clickDetector = part:FindFirstChild("ClickDetector") -- Znajdź ClickDetector w części

if clickDetector then
  local function onMouseClick(playerWhoClicked)
    -- 'playerWhoClicked' to obiekt gracza, który kliknął
    print(part.Name .. " został kliknięty przez gracza: " .. playerWhoClicked.Name)
    -- Tutaj można dodać logikę po kliknięciu
  end

  -- Podłączenie funkcji do zdarzenia 'MouseClick'
  clickDetector.MouseClick:Connect(onMouseClick)
end

Ważne: :Connect() służy do rejestrowania funkcji, która ma być wywołana, gdy zdarzenie wystąpi. :Wait() czeka, aż zdarzenie wystąpi raz i zwraca przekazane argumenty.

Specyfika Roblox (API)

Roblox dostarcza wiele wbudowanych obiektów (Instancji) i usług (Services), które pozwalają manipulować grą.

Workspace: Główny kontener na wszystkie widoczne obiekty w świecie gry (części, modele, postacie).
Players: Usługa zarządzająca graczami na serwerze.
ServerScriptService: Zalecane miejsce na skrypty serwerowe (niewidoczne dla klientów).
ReplicatedStorage: Miejsce na obiekty, które mają być dostępne zarówno dla serwera, jak i klientów.
StarterPlayer / StarterCharacterScripts / StarterPlayerScripts: Szablony dla skryptów, które są kopiowane do gracza/postaci, gdy dołączają do gry.
game: Główny obiekt reprezentujący całą grę. Daje dostęp do wszystkich usług, np. game.Workspace, game.Players.


-- Dostęp do usług
local Workspace = game:GetService("Workspace")
local Players = game:GetService("Players")
local ServerScriptService = game:GetService("ServerScriptService")

-- Znalezienie obiektu w Workspace
local specificPart = Workspace:FindFirstChild("NazwaTwojejCzesci")

if specificPart then
  print("Znaleziono część!")
  -- Zmiana właściwości części
  specificPart.BrickColor = BrickColor.new("Bright red") -- Zmiana koloru
  specificPart.Transparency = 0.5 -- Ustawienie przezroczystości
  specificPart.Anchored = true -- Zakotwiczenie części (nie będzie spadać)
else
  print("Nie znaleziono części o nazwie 'NazwaTwojejCzesci'")
end

-- Iteracja po wszystkich graczach
for _, player in pairs(Players:GetPlayers()) do
  print("Gracz online: " .. player.Name)
  -- Można tu np. nadać każdemu graczowi punkty
end

-- Reagowanie na dołączenie nowego gracza
Players.PlayerAdded:Connect(function(player)
  print("Nowy gracz dołączył: " .. player.Name)
  -- Tutaj można np. załadować dane gracza, stworzyć dla niego UI itp.

  -- Reagowanie na załadowanie postaci gracza
  player.CharacterAdded:Connect(function(character)
    print("Postać gracza " .. player.Name .. " została załadowana.")
    local humanoid = character:WaitForChild("Humanoid")
    -- Można tu np. ustawić maksymalne zdrowie, prędkość itp.
    -- humanoid.MaxHealth = 150
  end)
end)

-- Reagowanie na opuszczenie gry przez gracza
Players.PlayerRemoving:Connect(function(player)
  print("Gracz " .. player.Name .. " opuścił grę.")
  -- Tutaj można np. zapisać dane gracza
end)

Dalsza Nauka

To tylko absolutne podstawy. Aby tworzyć zaawansowane gry, warto zgłębić:

Bardziej zaawansowane użycie tabel (metatables).
Komunikację Klient-Serwer (RemoteEvents, RemoteFunctions).
Tworzenie interfejsów użytkownika (GUI).
Manipulację CFrame (pozycja i orientacja obiektów).
Fizykę i ograniczenia (Constraints).

Polecane zasoby: