Poradnik · Systemy gry

Jak zrobić ekwipunek w Roblox Studio

Ekwipunek wydaje się zadaniem od interfejsu, ale o tym, czy da się go zhakować i czy gubi przedmioty, decyduje miejsce, w którym przedmioty są przechowywane. W tym poradniku przedmioty każdego gracza leżą w tabeli na serwerze, każdy gracz dostaje kopię i rysuje ją jako siatkę, zakłada Tool i używa przedmiotów zużywalnych przez żądania, które sprawdza serwer, a wszystko zapisuje się w data store.

Zaktualizowano 20 listopada 202614 min czytaniaAutor:

W skrócie

Trzymaj przedmioty każdego gracza w tabeli na serwerze, w ModuleScript w ServerScriptService, i tylko ten kod może je dodawać, usuwać i układać w stosy. Opisz przedmioty raz w ModuleScript w ReplicatedStorage (id, nazwa, maksymalny stos). Po każdej zmianie serwer wysyła temu graczowi RemoteEvent z kopią jego ekwipunku, a LocalScript rysuje go jako siatkę przez ScrollingFrame i UIGridLayout.

  • Klient nigdy nie dodaje przedmiotów. Może tylko poprosić, na przykład "załóż mój miecz", a serwer sprawdza, czy gracz go ma, zanim cokolwiek zrobi.
  • Przedmioty pojawiają się tylko przez kod serwerowy, który kontrolujesz: podnoszenie, zakupy w sklepie po sprawdzeniu na serwerze, nagrody.
  • Zapisuj id przedmiotów i ich liczbę, a nie Toole, przez DataStoreService, gdy gracz wychodzi, gdy serwer się wyłącza i co kilka minut. Nigdy nie zapisuj gracza, którego dane się nie wczytały.
Na tej stronie
  1. Jak to działa
  2. Dlaczego przedmioty na serwerze
  3. 1. Przygotowujemy Explorer
  4. 2. Katalog przedmiotów
  5. 3. Ekwipunek na serwerze
  6. 4. Wczytywanie i zapis
  7. 5. Podnoszenie przedmiotów
  8. 6. Zakładanie i używanie
  9. 7. Siatka UI
  10. Sprawdzenie
  11. Common errors
  12. Z RoCode
  13. Najczęstsze pytania
  14. Źródła i dalsza lektura

Jak zbudowany jest ekwipunek

IlustracjaNaciśnij B, najedź kursorem na przedmiot, żeby przeczytać opis, kliknij Sword, żeby wziąć go do ręki.

System składa się z sześciu małych części, każda ma jedno zadanie. Wszystkie zasady dotyczące przedmiotów żyją w jednym module serwerowym, więc gdy coś się psuje, szukać trzeba dokładnie w jednym miejscu.

Części systemu i gdzie działają
CzęśćTyp i miejsceZadanie
ItemCatalogModuleScript w ReplicatedStorageCzym jest każdy przedmiot: nazwa, opis, maksymalny stos i czy można go założyć albo użyć. Czytają go serwer i wszyscy klienci.
InventoryServiceModuleScript w ServerScriptServicePrzechowuje sloty wszystkich graczy. Jedyny kod, który dodaje, usuwa i układa przedmioty w stosy.
InventoryDataScript w ServerScriptServiceWczytuje przedmioty gracza przy wejściu i je zapisuje.
InventoryActionsScript w ServerScriptServiceSprawdza i wykonuje żądania zakładania i używania.
ItemPickupScript w PartDaje przedmiot temu, kto go podniósł.
InventoryClientLocalScript w StarterPlayerScriptsRysuje siatkę i wysyła żądania. Sam niczego nie zmienia.

Dane płyną w jedną stronę. Serwer zmienia ekwipunek, potem wysyła temu graczowi InventoryUpdated z całym ekwipunkiem, a klient go przerysowuje. Gdy gracz klika slot, klient wysyła EquipItem albo UseItem z id przedmiotu; serwer sprawdza żądanie, wprowadza zmianę, a nowa kopia przychodzi tą samą drogą. Wysyłanie całego ekwipunku jest prostsze niż wysyłanie zmian, a dla kilkudziesięciu slotów wiadomość zostaje mała.

Dlaczego klient nigdy nie dodaje przedmiotów

Kusi, żeby dodać przedmiot prosto w LocalScript, który go pokazuje: gracz kliknął, slot się zapełnił. To psuje się na dwa sposoby.

  • Nikt inny tego nie widzi. Zmiana w LocalScript istnieje tylko na urządzeniu tego gracza. Serwer się o niej nie dowiaduje, więc się nie zapisuje i żaden serwerowy skrypt nie może jej użyć.
  • Podrobić może każdy. Jeśli naprawisz to remote’em w rodzaju AddItem(itemId, amount), oszust będzie mógł sam wywoływać ten event, z dowolnymi argumentami i dowolnie wiele razy. W poradniku Roblox o bezpieczeństwie napisano, że serwer musi sprawdzać wszystko, co przysyła klient, zanim tego użyje.

Dlatego w tym poradniku klient może tylko prosić o zrobienie czegoś z przedmiotami, które gracz już ma: "załóż to" i "użyj tego". W każdym żądaniu jest jedno id przedmiotu i żadnych ilości, a na serwerze przechodzi jedno sprawdzenie: to string, taki przedmiot istnieje, gracz ma co najmniej jeden i wysyła nie więcej niż cztery żądania na sekundę. Potem serwer sam znajduje Tool według katalogu. Nigdy nie przyjmuje od klienta Toola, ścieżki ani instancji, przed czym ostrzega ten sam poradnik.

Przedmioty trafiają do ekwipunku tylko przez kod serwerowy: podniesienie, które sprawdził serwer, zakup, za który serwer pobrał pieniądze (buduje go poradnik o sklepie), nagrodę za questa albo drop. O remote’ach w ogóle, ze sprawdzaniem innych rodzajów argumentów, przeczytaj w poradniku o RemoteEvent.

Krok 1: przygotuj Explorer

Utwórz te obiekty ręcznie. Skrypty z kolejnych kroków szukają ich po nazwie, więc pisz każdą nazwę dokładnie tak jak tutaj.

  1. W ReplicatedStorage wstaw Folder o nazwie InventoryRemotes. Do środka wstaw trzy RemoteEvent o nazwach InventoryUpdated, EquipItem i UseItem.
  2. W ServerStorage wstaw Folder o nazwie ItemTools. Do środka wstaw Tool o nazwie Sword, a do Toola Part o nazwie Handle (1 na 4 na 1 stud w zupełności wystarczy). Sprawdź, czy Anchored w Handle jest odznaczone: Roblox ostrzega, że postać utyka w miejscu, jeśli trzyma narzędzie z zakotwiczonymi partami. Pasuje też Tool, który już masz, jeśli jego nazwa zgadza się z katalogiem z kroku 2.
  3. Dodawaj skrypty w miarę przechodzenia kroków. Drzewo pokazuje, gdzie idzie każdy z nich.
Explorer po przejściu poradnika
ReplicatedStorage
  ItemCatalog ModuleScript new
  InventoryRemotes Folder new
    InventoryUpdated RemoteEvent new
    EquipItem RemoteEvent new
    UseItem RemoteEvent new
ServerScriptService
  InventoryService ModuleScript new
  InventoryData Script new
  InventoryActions Script new
ServerStorage
  ItemTools Folder new
    Sword Tool new
      Handle Part new
StarterPlayer
  StarterPlayerScripts
    InventoryClient LocalScript new
Workspace
  Apple Part new
    ItemPickup Script new

Krok 2: opisz przedmioty w katalogu

Katalog opisuje raz każdy przedmiot, który może istnieć. Ekwipunki przechowują potem tylko id przedmiotu i liczbę. Dzięki temu zapisy zostają małe, a później można zmienić nazwę przedmiotu albo przepisać jego opis, nie ruszając niczyich zapisanych danych.

Wstaw ModuleScript do ReplicatedStorage, nazwij go ItemCatalog i zastąp jego zawartość tym:

ModuleScript w ReplicatedStorage o nazwie ItemCatalog
-- Wszystkie przedmioty, które mogą istnieć w grze. Tę listę czytają serwer i wszyscy
-- klienci; tylko serwer decyduje, kto co ma.
export type Item = {
	id: string, -- musi zgadzać się z kluczem niżej
	name: string,
	description: string,
	maxStack: number, -- ile tego przedmiotu mieści się w jednym slocie
	icon: string?, -- opcjonalny obrazek: "rbxassetid://" plus ID twojego obrazu
	toolName: string?, -- Tool w ServerStorage.ItemTools: przedmiot można założyć
	heal: number?, -- ile zdrowia przywraca: przedmiot jest zużywalny
}

local items: { [string]: Item } = {
	sword = {
		id = "sword",
		name = "Sword",
		description = "Equip it to put it in your hand.",
		maxStack = 1,
		toolName = "Sword",
	},
	apple = {
		id = "apple",
		name = "Apple",
		description = "Use it to restore 25 health.",
		maxStack = 10,
		heal = 25,
	},
	wood = {
		id = "wood",
		name = "Wood",
		description = "A building material.",
		maxStack = 50,
	},
}

local ItemCatalog = {}

-- Zwraca przedmiot o tym id albo nil, jeśli takiego przedmiotu nie ma
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Opcjonalne pola decydują, co robi przedmiot. toolName sprawia, że można go założyć, heal sprawia, że można go użyć, a przedmiot bez obu pól, jak drewno, leży w ekwipunku, dopóki nie usunie go inny kod serwerowy (crafting, sprzedaż).

Żeby dodać przedmiot, dodaj wpis, w którym klucz i id są takie same. Id rozróżniają wielkość liter i to one są zapisywane, więc nigdy nie zmieniaj id, gdy gracze już mają przedmiot: zmieniaj jego name.

Krok 3: przechowuj ekwipunki na serwerze

Ten ModuleScript zarządza ekwipunkiem każdego gracza. Każdy ekwipunek to lista slotów, w każdym slocie id przedmiotu i liczba, plus pojemność 20 slotów. Inne serwerowe skrypty wywołują jego funkcje i nikt inny nie edytuje tabeli.

Wstaw ModuleScript do ServerScriptService i nazwij go InventoryService:

ModuleScript w ServerScriptService o nazwie InventoryService
-- Jedyny kod, który zmienia ekwipunki. Leży w ServerScriptService,
-- gdzie klienci nie mogą go ani zobaczyć, ani uruchomić.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Tryb strict nie widzi, co zwraca require przez WaitForChild, więc
-- opisujemy tę część modułu, której używa ten skrypt
type Item = { id: string, maxStack: number }
type Catalog = { get: (id: string) -> Item? }
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent

export type Slot = { id: string, count: number }
type Inventory = { slots: { Slot }, capacity: number, equipped: string? }

local CAPACITY = 20 -- slotów na gracza
local STARTER_ITEMS: { Slot } = { -- z czym zaczyna zupełnie nowy gracz
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

local inventories: { [Player]: Inventory } = {}

local InventoryService = {}

-- Wysyła właścicielowi kopię jego ekwipunku. Wywoływane po każdej zmianie.
local function sync(player: Player)
	local inventory = inventories[player]
	if inventory then
		inventoryUpdated:FireClient(player, {
			capacity = inventory.capacity,
			slots = inventory.slots,
			equipped = inventory.equipped,
		})
	end
end

-- Zasady stosów: najpierw dopełniamy niepełne stosy, potem zaczynamy nowe stosy
-- w pustych slotach. Zwraca, ile dodano, może to być mniej niż żądano.
local function addToInventory(inventory: Inventory, item: Item, amount: number): number
	local remaining = amount
	for _, slot in inventory.slots do
		if remaining == 0 then
			break
		end
		if slot.id == item.id and slot.count < item.maxStack then
			local moved = math.min(item.maxStack - slot.count, remaining)
			slot.count += moved
			remaining -= moved
		end
	end
	while remaining > 0 and #inventory.slots < inventory.capacity do
		local moved = math.min(item.maxStack, remaining)
		table.insert(inventory.slots, { id = item.id, count = moved })
		remaining -= moved
	end
	return amount - remaining
end

function InventoryService.count(player: Player, itemId: string): number
	local inventory = inventories[player]
	local total = 0
	if inventory then
		for _, slot in inventory.slots do
			if slot.id == itemId then
				total += slot.count
			end
		end
	end
	return total
end

-- Ile jeszcze przedmiotu się zmieści: miejsce w jego stosach plus puste sloty
function InventoryService.spaceFor(player: Player, itemId: string): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	if not inventory or not item then
		return 0
	end
	local space = (inventory.capacity - #inventory.slots) * item.maxStack
	for _, slot in inventory.slots do
		if slot.id == itemId then
			space += item.maxStack - slot.count
		end
	end
	return space
end

-- Dodaje do amount sztuk przedmiotu. Zwraca, ile dodano (0, jeśli
-- przedmiotu nie ma, ekwipunek jest pełny albo jeszcze się nie wczytał).
function InventoryService.add(player: Player, itemId: string, amount: number): number
	local inventory = inventories[player]
	local item = ItemCatalog.get(itemId)
	local wanted = math.floor(amount)
	if not inventory or not item or wanted < 1 then
		return 0
	end
	local added = addToInventory(inventory, item, wanted)
	if added > 0 then
		sync(player)
	end
	return added
end

-- Usuwa dokładnie amount sztuk przedmiotu, zaczynając od ostatnich stosów.
-- Jeśli gracz ma mniej, nic nie usuwa i zwraca false.
function InventoryService.remove(player: Player, itemId: string, amount: number): boolean
	local inventory = inventories[player]
	local wanted = math.floor(amount)
	if not inventory or wanted < 1 or InventoryService.count(player, itemId) < wanted then
		return false
	end
	local remaining = wanted
	-- Idziemy od końca, żeby table.remove nie pomijał slotów
	for index = #inventory.slots, 1, -1 do
		local slot = inventory.slots[index]
		if slot.id == itemId then
			local taken = math.min(slot.count, remaining)
			slot.count -= taken
			remaining -= taken
			if slot.count == 0 then
				table.remove(inventory.slots, index)
			end
			if remaining == 0 then
				break
			end
		end
	end
	sync(player)
	return true
end

function InventoryService.getEquipped(player: Player): string?
	local inventory = inventories[player]
	return if inventory then inventory.equipped else nil
end

function InventoryService.setEquipped(player: Player, itemId: string?)
	local inventory = inventories[player]
	if inventory then
		inventory.equipped = itemId
		sync(player)
	end
end

-- Wywoływane, gdy zapisane dane gracza się wczytały. saved to to, co
-- zwrócił data store: nil dla nowego gracza. Każdy wpis od nowa przechodzi przez
-- zasady stosów, więc usunięte przedmioty i stare rozmiary stosów niczego nie psują.
function InventoryService.load(player: Player, saved: any)
	local inventory: Inventory = { slots = {}, capacity = CAPACITY }
	local entries: { Slot } = STARTER_ITEMS
	if type(saved) == "table" and type(saved.slots) == "table" then
		entries = {}
		for _, entry in saved.slots do
			if type(entry) == "table" and type(entry.id) == "string" and type(entry.count) == "number" then
				table.insert(entries, { id = entry.id, count = math.floor(entry.count) })
			end
		end
	end
	for _, entry in entries do
		local item = ItemCatalog.get(entry.id)
		if item and entry.count > 0 then
			addToInventory(inventory, item, entry.count)
		end
	end
	inventories[player] = inventory
	sync(player)
end

-- Prosta kopia do zapisu albo nil, jeśli dane gracza nigdy się nie wczytały
function InventoryService.serialize(player: Player): { version: number, slots: { Slot } }?
	local inventory = inventories[player]
	if not inventory then
		return nil
	end
	local slots: { Slot } = {}
	for index, slot in inventory.slots do
		slots[index] = { id = slot.id, count = slot.count }
	end
	return { version = 1, slots = slots }
end

function InventoryService.unload(player: Player)
	inventories[player] = nil
end

return InventoryService

Linie type i rzutowanie :: po require są potrzebne tylko type checkerowi Luau, który nie widzi, co zwraca moduł znaleziony przez WaitForChild. W trakcie gry niczego nie zmieniają. Pozostałe skrypty w tym poradniku robią tak samo.

Jak działają zasady stosów z katalogiem wyżej, w którym jabłka stackują się do 10:

  • Jeśli dodasz 15 jabłek graczowi ze stosem 7, ten stos zapełni się do 10, a potem zacznie się nowy stos z 5.
  • Gdy slotów zabraknie, add dodaje to, co się zmieściło, i zwraca tę liczbę. Wywołuj najpierw spaceFor, gdy potrzebujesz wszystko albo nic, jak robi podnoszenie w kroku 5.
  • remove działa na zasadzie wszystko albo nic. Żądanie 3 jabłek od gracza, który ma 2, niczego nie usuwa i zwraca false, więc sprawdzaj wynik, zanim coś dasz w zamian.
  • W slotach nie ma dziur: gdy slot się opróżnia, pozostałe przesuwają się w górę. Tak listę łatwiej wysyłać i zapisywać. O slotach, które trzymają swoją pozycję, opowiadają pytania na końcu.
Co mogą wywoływać inne serwerowe skrypty
FunkcjaZwracaDo czego
add(player, itemId, amount)Ile dodanoPodnoszenie, nagrody, zakupy
remove(player, itemId, amount)true, jeśli usunięto wszystkoUżywanie, sprzedaż, crafting
count(player, itemId)Suma ze wszystkich stosówSprawdzić, co ma gracz
spaceFor(player, itemId)Ile jeszcze się zmieściSprawdzenie przed dodaniem na zasadzie wszystko albo nic
getEquipped, setEquippedId założonego przedmiotu albo nilZakładanie, w kroku 6
load, serialize, unloadKopia gotowa do zapisu (serialize)Wczytywanie i zapis, w kroku 4

Krok 4: wczytuj i zapisuj każdy ekwipunek

Ekwipunki żyją w pamięci serwera, więc znikają, gdy gracz wychodzi. Ten skrypt wczytuje sloty gracza z data store, gdy wchodzi, i zapisuje je z powrotem, gdy wychodzi, gdy serwer się wyłącza i co trzy minuty na wypadek crasha serwera. Zapisuje tylko id przedmiotów i liczbę: data store nie umie przechowywać Instance, na przykład Toola.

Wstaw Script do ServerScriptService i nazwij go InventoryData:

Script w ServerScriptService o nazwie InventoryData
local Players = game:GetService("Players")
local DataStoreService = game:GetService("DataStoreService")
local RunService = game:GetService("RunService")
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	load: (player: Player, saved: any) -> (),
	serialize: (player: Player) -> any,
	unload: (player: Player) -> (),
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local STORE_NAME = "PlayerInventory_v1"
local LOAD_ATTEMPTS = 3
local AUTOSAVE_SECONDS = 180

-- Zapisywani są tylko gracze, których dane się wczytały. Po nieudanym wczytaniu
-- nie wolno zapisywać, inaczej pusty ekwipunek zastąpi prawdziwy.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

local function keyFor(player: Player): string
	return "User_" .. player.UserId
end

-- Jedno nieudane zapytanie nie może nikogo kosztować przedmiotów, więc próbujemy kilka razy.
-- GetDataStore też jest w pcall, więc sesja Studio bez dostępu do data
-- store dostaje ostrzeżenie, a nie zatrzymuje tego skryptu.
local function loadSaved(player: Player): (boolean, any)
	for attempt = 1, LOAD_ATTEMPTS do
		local ok, result = pcall(function()
			return DataStoreService:GetDataStore(STORE_NAME):GetAsync(keyFor(player))
		end)
		if ok then
			return true, result
		end
		warn(`Inventory load failed for {player.Name} (attempt {attempt}): {result}`)
		if attempt < LOAD_ATTEMPTS then
			task.wait(attempt * 2)
		end
	end
	return false, nil
end

local function onPlayerAdded(player: Player)
	local ok, saved = loadSaved(player)
	if player.Parent ~= Players then
		return -- gracz wyszedł, gdy wczytywaliśmy
	end
	if ok then
		InventoryService.load(player, saved) -- saved jest nil dla nowego gracza
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Zwykle oznacza, że dostęp Studio do API services jest wyłączony. Gramy ze
		-- startowymi przedmiotami, żeby dało się testować, ale nigdy ich nie zapisujemy.
		warn("Inventory not loaded: playing with starter items that will not be saved")
		InventoryService.load(player, nil)
	else
		player:Kick("Your inventory could not be loaded. Please rejoin in a minute.")
	end
end

local function save(player: Player)
	if not canSave[player] then
		return -- dane nigdy się nie wczytały, nie ma czego bezpiecznie zapisać
	end
	local data = InventoryService.serialize(player)
	if not data then
		return
	end
	activeSaves += 1
	local ok, err = pcall(function()
		DataStoreService:GetDataStore(STORE_NAME):SetAsync(keyFor(player), data, { player.UserId })
	end)
	activeSaves -= 1
	if not ok then
		warn(`Inventory save failed for {player.Name}: {err}`)
	end
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do
	task.spawn(onPlayerAdded, player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	save(player)
	canSave[player] = nil
	InventoryService.unload(player)
end)

-- Gdy serwer się wyłącza, zapisujemy wszystkich, którzy jeszcze tu są, i czekamy na każdy
-- trwający zapis, łącznie z tymi, które uruchomił PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Zapisujemy wszystkich co kilka minut, żeby crash serwera kosztował minuty, a nie całą sesję
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Co robi skrypt i po co:

  • Wczytywanie z wartościami domyślnymi. Nowy gracz nie ma zapisanej wartości, więc GetAsync zwraca nil i dostaje on startowe przedmioty. Zapisane sloty od nowa przechodzą przez zasady stosów, więc przedmiot usunięty z katalogu albo zmniejszony maksymalny stos nie zepsują wczytywania. Wszystko, co już się nie mieści albo czyjego id nie ma już w katalogu, jest odrzucane, a następny zapis czyni to ostatecznym, więc trzymaj w katalogu każde id, które mogą mieć gracze.
  • Nigdy nie zapisywać po nieudanym wczytaniu. Zapisywani są tylko gracze z canSave. Na opublikowanym serwerze gracza, którego dane nie wczytały się nawet po trzech próbach, prosi się o ponowne wejście. W Studio dostaje zamiast tego niezapisywane startowe przedmioty, kilka sekund później przez ponowne próby. Tak będzie, dopóki gra nie zostanie opublikowana z włączonym dostępem do API.
  • Zapis przy wyjściu i przy wyłączaniu. BindToClose zapisuje wszystkich, którzy są jeszcze na serwerze, i czeka na już trwające zapisy. Roblox daje podpiętym funkcjom do 30 sekund.
  • Nie wychodzić poza limity. Jeden zapis na gracza co trzy minuty plus jeden przy wyjściu to dużo mniej niż standardowy budżet serwera 60 zapisów na minutę plus 40 na każdego gracza (według dokumentacji z 30 września 2026). Wzorzec klucza User_ pochodzi z zaleceń Roblox, a przekazanie user ID do SetAsync wiąże dane z tym graczem, co Roblox mocno zaleca do obsługi żądań usunięcia danych.

Dla małej gry to solidna podstawa. Blokada sesji, która nie pozwala graczowi, który szybko zmienił serwer, wczytać danych, zanim stary serwer je zapisze, i kiedy używać UpdateAsync zamiast SetAsync, są omówione w poradniku o DataStore.

Krok 5: dawaj przedmioty ze świata

Podnoszenie to najprostszy sposób, w jaki przedmioty trafiają do ekwipunku: part z ProximityPrompt, który dodaje przedmiot, gdy gracz go użyje. Skrypt nasłuchuje jego eventu Triggered na serwerze, więc przedmiot jest dodawany tam, gdzie klient nie może się wtrącić.

  1. Dodaj Part do Workspace, nazwij go Apple i pomaluj na czerwono. Włącz Anchored i wyłącz CanCollide, żeby nikt w niego nie wpadał, gdy jest niewidoczny. Podpowiedź pokazuje nazwę partu.
  2. Z zaznaczonym partem przewiń okno Properties do sekcji Attributes i kliknij +. Dodaj ItemId typu string i kliknij Save, potem ustaw wartość apple. Tak samo dodaj Amount typu number z wartością 1.
  3. Wstaw Script do partu, nazwij go ItemPickup i wklej ten kod:
Script w parcie Apple w Workspace o nazwie ItemPickup
-- Włóż ten Script do Part i daj Part dwa atrybuty:
-- ItemId (string, na przykład apple) i Amount (liczba, na przykład 1).
local ServerScriptService = game:GetService("ServerScriptService")

type InventoryApi = {
	add: (player: Player, itemId: string, amount: number) -> number,
	spaceFor: (player: Player, itemId: string) -> number,
}
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local part = script.Parent :: BasePart
local RESPAWN_SECONDS = 15

local itemId = part:GetAttribute("ItemId")
local amount = part:GetAttribute("Amount")
if typeof(itemId) ~= "string" or typeof(amount) ~= "number" or amount < 1 then
	error(`{part:GetFullName()} needs an ItemId (string) and an Amount (number, 1 or more) attribute`)
end

local prompt = Instance.new("ProximityPrompt")
prompt.ActionText = "Pick up"
prompt.ObjectText = part.Name
prompt.Parent = part

local visibleTransparency = part.Transparency

prompt.Triggered:Connect(function(player: Player)
	if not prompt.Enabled then
		return -- ktoś inny właśnie go podniósł
	end
	-- Sprawdzamy odległość na serwerze, zamiast wierzyć żądaniu
	local character = player.Character
	if not character then
		return
	end
	local distance = (character:GetPivot().Position - part.Position).Magnitude
	if distance > prompt.MaxActivationDistance + 5 then
		return
	end
	if InventoryService.spaceFor(player, itemId) < amount then
		return -- brak miejsca: zostawiamy przedmiot na miejscu
	end
	InventoryService.add(player, itemId, amount)

	prompt.Enabled = false
	part.Transparency = 1
	task.wait(RESPAWN_SECONDS)
	part.Transparency = visibleTransparency
	prompt.Enabled = true
end)

Kopiuj part, żeby rozstawić więcej przedmiotów. Zmieniaj atrybuty, żeby dawać drewno, kolejny miecz albo stos jabłek.

Roblox sprawdza odległość dla Triggered, ale jego poradnik o bezpieczeństwie i tak każe sprawdzać podpowiedzi na serwerze: oszust może wywoływać eventy podpowiedzi, nawet gdy Enabled jest false, i może przyciągnąć niezakotwiczony part do swojej postaci. Dlatego skrypt sam sprawdza Enabled i odległość i dlatego part jest zakotwiczony.

Każdy inny serwerowy skrypt daje przedmioty tak samo. Po zakupie, queście albo zabójstwie podłącz InventoryService przez require, jak skrypty wyżej, i wywołaj InventoryService.add(player, "wood", 5). Najpierw sprawdzaj spaceFor, gdy przedmiotu nie wolno stracić. Kolejnym źródłem może być NPC: w poradniku o dialogach z NPC odpowiedź uruchamia akcję na serwerze, a ta akcja może tak samo wywołać InventoryService.add.

Krok 6: zakładanie Toola i używanie przedmiotów

Dwa RemoteEvent niosą jedyne żądania, jakie może wysłać klient. EquipItem wkłada kopię Toola przedmiotu z ServerStorage do Backpack gracza (hotbar na dole ekranu) i do jego ręki, a ponowne żądanie ją zdejmuje. UseItem usuwa jedną sztukę przedmiotu do użycia i stosuje jego efekt, tutaj to leczenie.

Wstaw Script do ServerScriptService i nazwij go InventoryActions:

Script w ServerScriptService o nazwie InventoryActions
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local ServerScriptService = game:GetService("ServerScriptService")
local ServerStorage = game:GetService("ServerStorage")

type Item = { id: string, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type InventoryApi = {
	count: (player: Player, itemId: string) -> number,
	remove: (player: Player, itemId: string, amount: number) -> boolean,
	getEquipped: (player: Player) -> string?,
	setEquipped: (player: Player, itemId: string?) -> (),
}
local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local InventoryService = require(ServerScriptService:WaitForChild("InventoryService")) :: InventoryApi

local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent
local itemTools = ServerStorage:WaitForChild("ItemTools")

local COOLDOWN_SECONDS = 0.25
local lastRequest: { [Player]: number } = {}

-- Każde żądanie zaczyna się tutaj. Klient może przysłać cokolwiek i kiedykolwiek, więc
-- sprawdzamy typ, czy przedmiot istnieje, czy gracz go ma, i częstotliwość.
local function ownedItem(player: Player, itemId: unknown): Item?
	if typeof(itemId) ~= "string" then
		return nil
	end
	local now = os.clock()
	if now - (lastRequest[player] or 0) < COOLDOWN_SECONDS then
		return nil
	end
	lastRequest[player] = now
	local item = ItemCatalog.get(itemId)
	if not item or InventoryService.count(player, itemId) < 1 then
		return nil
	end
	return item
end

-- Niszczy Tool tego przedmiotu, gdziekolwiek jest kopia: hotbar, ręka albo StarterGear
local function destroyTools(container: Instance?, itemId: string)
	if not container then
		return
	end
	for _, child in container:GetChildren() do
		if child:IsA("Tool") and child:GetAttribute("InventoryItem") == itemId then
			child:Destroy()
		end
	end
end

local function unequip(player: Player)
	local equippedId = InventoryService.getEquipped(player)
	if equippedId then
		destroyTools(player:FindFirstChildOfClass("Backpack"), equippedId)
		destroyTools(player.Character, equippedId)
		destroyTools(player:FindFirstChildOfClass("StarterGear"), equippedId)
		InventoryService.setEquipped(player, nil)
	end
end

local function equip(player: Player, item: Item, toolName: string)
	local template = itemTools:FindFirstChild(toolName)
	local backpack = player:FindFirstChildOfClass("Backpack")
	if not template or not template:IsA("Tool") or not backpack then
		warn(`Cannot equip {item.id}: no Tool named {toolName} in ServerStorage.ItemTools`)
		return
	end
	unequip(player) -- jedno założone narzędzie naraz

	local tool = template:Clone()
	tool.CanBeDropped = false -- wyrzuconą kopię mógłby podnieść ktoś inny
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Druga kopia w StarterGear kopiuje się z powrotem do Backpack po respawnie
	local starterGear = player:FindFirstChildOfClass("StarterGear")
	if starterGear then
		local gearCopy = tool:Clone()
		gearCopy.Parent = starterGear
	end

	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if humanoid and humanoid.Health > 0 then
		humanoid:EquipTool(tool) -- od razu do ręki
	end
	InventoryService.setEquipped(player, item.id)
end

equipItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.toolName then
		return
	end
	if InventoryService.getEquipped(player) == item.id then
		unequip(player) -- ponowne kliknięcie założonego przedmiotu go zdejmuje
	else
		equip(player, item, item.toolName)
	end
end)

useItem.OnServerEvent:Connect(function(player: Player, itemId: unknown)
	local item = ownedItem(player, itemId)
	if not item or not item.heal then
		return
	end
	local heal = item.heal
	local character = player.Character
	local humanoid = character and character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return -- martwy albo już z pełnym zdrowiem: nie marnujemy przedmiotu
	end
	-- Najpierw zabieramy przedmiot i leczymy tylko wtedy, gdy się udało
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
Na co pozwala każde żądanie
ŻądanieKlient przysyłaSerwer sprawdza przed działaniem
EquipItemId przedmiotuTo string, przedmiot istnieje, gracz go ma, żądania przychodzą nie częściej niż cztery na sekundę, przedmiot ma toolName, a Tool o tej nazwie leży w ServerStorage.ItemTools
UseItemId przedmiotuTe same sprawdzenia typu, posiadania i częstotliwości, przedmiot ma wartość heal, postać żyje i jest ranna, a jeden przedmiot zostaje usunięty, zanim zdrowie zostanie dodane

Trzy szczegóły nie pozwalają Toolowi się zduplikować albo zgubić. Kopia ma CanBeDropped ustawione na false, bo wyrzucony Tool spada do Workspace, gdzie może go zabrać inny gracz, a oryginał zostaje przy tym w ekwipunku. Każda kopia niesie atrybut InventoryItem, więc przy zdejmowaniu można znaleźć i zniszczyć każdą kopię, gdziekolwiek jest. A jeśli gracz ma kontener StarterGear, trafia do niego druga kopia. Roblox kopiuje StarterGear do Backpack przy każdym pojawieniu się postaci, więc założony miecz wraca po respawnie.

Założony jest tylko jeden Tool naraz, a założenie się nie zapisuje, więc gracz po ponownym wejściu zaczyna z pustym hotbarem. Jeśli później dodasz sprzedaż albo wyrzucanie, zdejmuj przedmiot, zanim jego ostatnia kopia opuści ekwipunek.

Miecz-zaślepkę można zamienić w miecz, który naprawdę walczy: zbuduj Tool według poradnika o mieczu, zostaw mu nazwę Sword i włóż do ItemTools zamiast zaślepki. Serwerowy skrypt z tamtego poradnika będzie sprawdzał każdy cios, niezależnie od tego, jak gracz dostał miecz.

Krok 7: narysuj siatkę ekwipunku

LocalScript buduje całe okno w kodzie, więc niczego nie trzeba rozstawiać ręcznie. ScrollingFrame trzyma sloty, UIGridLayout w nim układa je w rzędy, a AutomaticCanvasSize powiększa przewijany obszar w miarę dodawania rzędów.

W Explorerze otwórz StarterPlayer, wstaw LocalScript do StarterPlayerScripts i nazwij go InventoryClient:

LocalScript w StarterPlayerScripts o nazwie InventoryClient
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local UserInputService = game:GetService("UserInputService")

type Item = { name: string, description: string, icon: string?, toolName: string?, heal: number? }
type Catalog = { get: (id: string) -> Item? }
type Slot = { id: string, count: number }
type Snapshot = { capacity: number, slots: { Slot }, equipped: string? }

local ItemCatalog = require(ReplicatedStorage:WaitForChild("ItemCatalog")) :: Catalog
local remotes = ReplicatedStorage:WaitForChild("InventoryRemotes")
local inventoryUpdated = remotes:WaitForChild("InventoryUpdated") :: RemoteEvent
local equipItem = remotes:WaitForChild("EquipItem") :: RemoteEvent
local useItem = remotes:WaitForChild("UseItem") :: RemoteEvent

local player = Players.LocalPlayer
local TOGGLE_KEY = Enum.KeyCode.B

local COLOURS = {
	panel = Color3.fromRGB(24, 20, 36),
	slot = Color3.fromRGB(44, 38, 64),
	empty = Color3.fromRGB(34, 30, 48),
	equipped = Color3.fromRGB(124, 77, 255),
	text = Color3.fromRGB(240, 238, 245),
	muted = Color3.fromRGB(170, 165, 185),
}

local function addCorner(parent: GuiObject, radius: number)
	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, radius)
	corner.Parent = parent
end

local function makeLabel(parent: GuiObject, text: string, textSize: number): TextLabel
	local label = Instance.new("TextLabel")
	label.BackgroundTransparency = 1
	label.Font = Enum.Font.BuilderSansBold
	label.TextColor3 = COLOURS.text
	label.TextSize = textSize
	label.Text = text
	label.Parent = parent
	return label
end

-- 1. Budujemy okno raz. ResetOnSpawn = false zachowuje je po respawnach.
local gui = Instance.new("ScreenGui")
gui.Name = "InventoryGui"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

local openButton = Instance.new("TextButton")
openButton.AnchorPoint = Vector2.new(0, 0.5)
openButton.Position = UDim2.new(0, 16, 0.5, 0)
openButton.Size = UDim2.fromOffset(140, 40)
openButton.BackgroundColor3 = COLOURS.panel
openButton.Font = Enum.Font.BuilderSansBold
openButton.TextColor3 = COLOURS.text
openButton.TextSize = 18
openButton.Text = "Inventory (B)"
addCorner(openButton, 8)
openButton.Parent = gui

local panel = Instance.new("Frame")
panel.AnchorPoint = Vector2.new(0.5, 0.5)
panel.Position = UDim2.fromScale(0.5, 0.5)
panel.Size = UDim2.fromScale(0.9, 0.8)
panel.BackgroundColor3 = COLOURS.panel
panel.Visible = false
addCorner(panel, 12)
panel.Parent = gui

local sizeLimit = Instance.new("UISizeConstraint")
sizeLimit.MaxSize = Vector2.new(440, 400)
sizeLimit.Parent = panel

local title = makeLabel(panel, "Inventory", 22)
title.Position = UDim2.fromOffset(16, 8)
title.Size = UDim2.new(1, -32, 0, 32)
title.TextXAlignment = Enum.TextXAlignment.Left

local slotCount = makeLabel(panel, "", 16)
slotCount.Position = UDim2.fromOffset(16, 8)
slotCount.Size = UDim2.new(1, -32, 0, 32)
slotCount.TextColor3 = COLOURS.muted
slotCount.TextXAlignment = Enum.TextXAlignment.Right

local grid = Instance.new("ScrollingFrame")
grid.Position = UDim2.fromOffset(12, 48)
grid.Size = UDim2.new(1, -24, 1, -100)
grid.BackgroundTransparency = 1
grid.BorderSizePixel = 0
grid.CanvasSize = UDim2.new() -- AutomaticCanvasSize powiększa go pod komórki
grid.AutomaticCanvasSize = Enum.AutomaticSize.Y
grid.ScrollingDirection = Enum.ScrollingDirection.Y
grid.ScrollBarThickness = 6
grid.Parent = panel

local layout = Instance.new("UIGridLayout")
layout.CellSize = UDim2.fromOffset(72, 72)
layout.CellPadding = UDim2.fromOffset(8, 8)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = grid

local info = makeLabel(panel, "Click an item to equip or use it.", 16)
info.AnchorPoint = Vector2.new(0, 1)
info.Position = UDim2.new(0, 16, 1, -8)
info.Size = UDim2.new(1, -32, 0, 40)
info.Font = Enum.Font.BuilderSans
info.TextColor3 = COLOURS.muted
info.TextWrapped = true
info.TextXAlignment = Enum.TextXAlignment.Left

-- 2. Jedna komórka na slot. To tylko rysuje to, co przysłał serwer; sam
-- ekwipunek nigdy się stąd nie zmienia.
local function makeCell(index: number, slot: Slot?, equippedId: string?)
	local cell = Instance.new("TextButton")
	cell.LayoutOrder = index
	cell.Text = ""
	cell.AutoButtonColor = slot ~= nil
	cell.BackgroundColor3 = if slot then COLOURS.slot else COLOURS.empty
	addCorner(cell, 8)
	cell.Parent = grid
	if not slot then
		return -- pusty slot
	end

	local itemId = slot.id
	local item = ItemCatalog.get(itemId)
	local name = if item then item.name else itemId

	if item and item.icon then
		local image = Instance.new("ImageLabel")
		image.BackgroundTransparency = 1
		image.Size = UDim2.fromScale(1, 1)
		image.Image = item.icon
		image.Parent = cell
	else
		local nameLabel = makeLabel(cell, name, 14)
		nameLabel.Size = UDim2.fromScale(1, 1)
		nameLabel.TextWrapped = true
	end

	if slot.count > 1 then
		local countLabel = makeLabel(cell, `x{slot.count}`, 14)
		countLabel.AnchorPoint = Vector2.new(1, 1)
		countLabel.Position = UDim2.new(1, -6, 1, -4)
		countLabel.Size = UDim2.fromOffset(40, 16)
		countLabel.TextXAlignment = Enum.TextXAlignment.Right
	end

	if itemId == equippedId then
		local outline = Instance.new("UIStroke")
		outline.ApplyStrokeMode = Enum.ApplyStrokeMode.Border
		outline.Color = COLOURS.equipped
		outline.Thickness = 3
		outline.Parent = cell
	end

	cell.MouseEnter:Connect(function()
		info.Text = if item then `{item.name}: {item.description}` else name
	end)
	cell.Activated:Connect(function()
		-- Prosimy, a nie rozkazujemy: serwer sprawdza żądanie i przysyła wynik
		if item and item.toolName then
			equipItem:FireServer(itemId)
		elseif item and item.heal then
			useItem:FireServer(itemId)
		end
	end)
end

local function render(snapshot: Snapshot)
	for _, child in grid:GetChildren() do
		if child:IsA("GuiButton") then
			child:Destroy()
		end
	end
	for index = 1, snapshot.capacity do
		makeCell(index, snapshot.slots[index], snapshot.equipped)
	end
	slotCount.Text = `{#snapshot.slots} / {snapshot.capacity} slots`
end

-- Serwer wysyła to po wczytaniu i po każdej zmianie
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Otwieramy i zamykamy przyciskiem albo klawiszem B
local function toggle()
	panel.Visible = not panel.Visible
end

openButton.Activated:Connect(toggle)
UserInputService.InputBegan:Connect(function(input: InputObject, gameProcessedEvent: boolean)
	if not gameProcessedEvent and input.KeyCode == TOGGLE_KEY then
		toggle()
	end
end)

LocalScript w StarterPlayerScripts uruchamia się raz na sesję, a ResetOnSpawn = false zachowuje ScreenGui przy respawnie postaci, więc siatka dalej pokazuje ostatnią kopię, którą przysłał serwer.

Klient rysuje po komórce na każdy slot, łącznie z pustymi, więc ekwipunek na 20 slotów zawsze wygląda jak 20 slotów. Każda aktualizacja niszczy stare komórki i buduje nowe, to proste i pasuje do kilkudziesięciu slotów. Jeśli serwer wyśle InventoryUpdated, zanim ten skrypt się do niego podłączy, Roblox ustawi wiadomość w kolejce i dostarczy ją, gdy tylko handler się podłączy, więc pierwszy ekwipunek się nie zgubi.

Chcesz narysować okno w Studio? Zbuduj ScreenGui z jednym slotem-szablonem i rób mu Clone w makeCell. Dla ikon ustaw przedmiotowi w katalogu icon z wgranym przez ciebie obrazem, a jego komórka pokaże obrazek zamiast nazwy.

Sprawdź ekwipunek

  1. Kliknij Play. Otwórz ekwipunek przyciskiem po lewej albo klawiszem B: nowy gracz ma Sword i 3 Apple, a licznik pokazuje 2 / 20 slots. Dopóki Studio nie może korzystać z data store, przedmioty pojawiają się po kilku sekundach, po ostrzeżeniach o wczytywaniu w Output, i się nie zapisują.
  2. Kliknij Sword. Miecz pojawi się w twojej ręce i na hotbarze, a jego slot dostanie fioletową ramkę. Kliknij jeszcze raz, żeby go zdjąć.
  3. Podejdź do partu Apple i użyj jego podpowiedzi. Stos jabłek urośnie do 4, a part zniknie na 15 sekund.
  4. Żeby sprawdzić leczenie, najpierw zmniejsz zdrowie. Przełącz Client/Server na Server, zaznacz Humanoid swojej postaci w Explorerze, ustaw Health na 50, przełącz z powrotem na Client i kliknij Apple.
  5. Z włączonym dostępem Studio do API services zatrzymaj grę i uruchom ją znowu. Podniesione jabłko jest na miejscu. Jeśli wczytanie albo zapis się nie udały, Output to powie.

Żeby sprawdzić z kilkoma graczami, wybierz w ustawieniach testu Server & Clients z 2 klientami. Każdy gracz widzi tylko swój ekwipunek, a miecz w ręce drugiego widzą obaj.

Częste błędy i rozwiązania

Większość problemów widać w oknie Output jako ostrzeżenie albo czerwoną linię błędu. Czytaj pierwszą: kolejne błędy często z niej wynikają.

Infinite yield possible przy wywołaniu WaitForChild

Skrypt czeka na obiekt, którego nie ma pod dokładnie taką nazwą. Porównaj swój Explorer z drzewem z kroku 1: InventoryRemotes z trzema RemoteEvent w ReplicatedStorage, ItemTools w ServerStorage i dwa moduły. Nazwy rozróżniają wielkość liter. Poradnik o błędach skryptów omawia to ostrzeżenie dokładniej.

Siatka się otwiera, ale zostaje pusta

Klient rysuje tylko to, co przysyła serwer. Poszukaj w Output ostrzeżeń Inventory load failed i sprawdź, czy InventoryData to Script, a nie LocalScript, w ServerScriptService, a obok leży ModuleScript InventoryService. Jeśli Output pokazuje błąd Remote event invocation, na kliencie nikt nie nasłuchuje InventoryUpdated: szukaj wcześniejszego błędu od InventoryClient.

Przedmioty resetują się za każdym razem, gdy gram w Studio

Jeśli Output pisze Inventory not loaded: playing with starter items that will not be saved, gra nie jest opublikowana albo dostęp Studio do API services jest wyłączony. Włącz go, jak opisano w kroku 4, w kopii testowej swojej gry.

Kliknięcie miecza nic nie robi

Poszukaj w Output Cannot equip sword: Tool w ServerStorage.ItemTools musi nazywać się dokładnie jak toolName w katalogu. Tool potrzebuje też partu o nazwie Handle, żeby dało się go trzymać, chyba że ustawiłeś jego RequiresHandle na false.

Podpowiedź podnoszenia się pojawia, ale nic się nie dodaje

Atrybut ItemId musi dokładnie zgadzać się z id z katalogu, łącznie z wielkością liter: apple, a nie Apple. Nic się nie dodaje, gdy ekwipunek gracza jeszcze się wczytuje albo gdy nie ma miejsca na całą ilość.

Zapis się psuje po tym, jak zmieniłem, co jest zapisywane

Data store przyjmują proste dane: stringi, liczby, wartości logiczne i tabele z nich. Zapis Toola, Partu albo dowolnej innej Instance się wywala albo wartość zapisuje się jako nil. Zapisuj id przedmiotu i liczbę, a wszystko inne odtwarzaj z katalogu, jak robi serialize.

Zrób to z RoCode

Jeśli łatwiej ci opisać system, niż budować go ręcznie, RoCode może go zbudować w grze, którą masz otwartą. To agent AI do Roblox Studio: opisujesz funkcję na czacie w przeglądarce, a jego plugin do Studio tworzy skrypty i obiekty w twoim Explorerze, a nie daje kodu do wklejenia.

Ty piszesz

Dodaj ekwipunek na 20 slotów ze stosami przedmiotów, siatkę UI, która otwiera się pod B, miecz z ServerStorage, który gracze mogą zakładać, jabłka, które leczą, i zapis przez DataStoreService.

RoCode robi
  • Może przejrzeć twoją grę, gdy krok tego wymaga, przez Search Game i Search Scripts, żeby oprzeć się na istniejących przedmiotach, remote’ach albo kodzie zapisu, zamiast dodawać drugi system
  • Tworzy foldery i RemoteEvent przez Create Instance, a ModuleScript, Script i LocalScript przez Create Script
  • Może zbudować szkielet okna przez Build UI, gdzie jest układ ekwipunku ze slotami-zaślepkami; kod, który wypełnia sloty z serwera, jest pisany osobnymi skryptami
  • Sprawdza kompilację każdego skryptu w Studio przez Check Script, który wyłapuje błędy kompilacji i kilka ryzykownych wzorców, ale nie sprawdza typów, nie lintuje i nie uruchamia twojego kodu

Każda paczka zmian to punkt cofania w Studio. RoCode nie może włączyć dostępu Studio do API services, to robisz sam. Z pluginem 3.9 lub nowszym może uruchomić krótki playtest i przeczytać błędy, a z pluginem 3.9.15 lub nowszym jego testowa postać może naciskać klawisze i zakładać przedmioty, ale sprawdza tylko to, co sam postanowił przetestować, więc zapis sprawdź playtestem sam. Ekwipunek stoi na innych systemach, takich jak zapis i narzędzia, a kreator gier AI, który buduje w twojej własnej grze w Studio, dodaje je po jednym prompcie naraz. Jak RoCode łączy się ze Studio.

Najczęstsze pytania

Używać Backpack w Roblox zamiast własnego ekwipunku?

Backpack to wbudowany ekwipunek Roblox: każdy Tool w nim pokazuje się jako przycisk na hotbarze. Jeśli wszystkie przedmioty w twojej grze to Toole i nie potrzebujesz stosów, ilości ani limitu slotów, może wystarczyć, choć zapisywać, jakie Toole ma każdy gracz, i tak trzeba. Własny ekwipunek jest potrzebny do przedmiotów, które nie są Toolami, na przykład materiałów i przedmiotów zużywalnych. W tym poradniku używa się obu: ekwipunek przechowuje wszystko, a Backpack trzyma założony Tool.

Jak ukryć standardowy hotbar w Roblox?

Z LocalScript wywołaj StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Gdy hotbar jest ukryty, gracze potrzebują innego sposobu, żeby wziąć i zdjąć założony Tool, na przykład przycisku, który prosi serwer o wywołanie Humanoid:EquipTool albo Humanoid:UnequipTools.

Jak sprawić, żeby sloty trzymały pozycję dla drag and drop?

Trzymaj listę stałej długości z jednym wpisem na slot i oznaczaj puste sloty wartością w rodzaju pustego id, a nie nil, bo Roblox nie radzi wysyłać tabel z nil przez RemoteEvent. Potem dodaj RemoteEvent MoveItem, który przysyła dwa numery slotów, i niech serwer sprawdza, czy oba to liczby całkowite od 1 do pojemności, zanim zamieni je miejscami.

Jak duży może być zapisany ekwipunek?

Jedna wartość w data store może zajmować do 4 194 304 znaków po serializacji (według dokumentacji z 30 września 2026). Lista id i ilości zajmuje znikomą część tego. Rozmiar zapisu zwiększa tekst na każdy przedmiot, na przykład własne nazwy albo długie opisy zapisane dla każdego przedmiotu.

Jak kupować i sprzedawać przedmioty za monety?

Rób wszystko na serwerze. Żeby sprzedać, wywołaj InventoryService.remove i płać tylko wtedy, gdy zwrócił true. Żeby kupić, sprawdź cenę i spaceFor, zabierz monety, potem wywołaj add. Poradnik o sklepie buduje stronę zakupu.

Źródła i dalsza lektura

Jak sprawdziliśmy kod: każdy skrypt na tej stronie przechodzi ścisłe sprawdzanie typów Luau z definicjami API Robloxa (luau-lsp, 20 listopada 2026). Sprawdzanie typów wyłapuje źle wpisane API i błędne typy, ale nie logikę gry, więc przetestuj go w Studio przed publikacją.

Wypróbuj RoCode we własnej grze.

Darmowe kredyty codziennie, bez karty. Zainstaluj plugin, opisz funkcję i sprawdź, co pojawi się w Studio.