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
Jak zbudowany jest ekwipunek
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ęść | Typ i miejsce | Zadanie |
|---|---|---|
ItemCatalog | ModuleScript w ReplicatedStorage | Czym 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. |
InventoryService | ModuleScript w ServerScriptService | Przechowuje sloty wszystkich graczy. Jedyny kod, który dodaje, usuwa i układa przedmioty w stosy. |
InventoryData | Script w ServerScriptService | Wczytuje przedmioty gracza przy wejściu i je zapisuje. |
InventoryActions | Script w ServerScriptService | Sprawdza i wykonuje żądania zakładania i używania. |
ItemPickup | Script w Part | Daje przedmiot temu, kto go podniósł. |
InventoryClient | LocalScript w StarterPlayerScripts | Rysuje 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.
- W ReplicatedStorage wstaw Folder o nazwie
InventoryRemotes. Do środka wstaw trzy RemoteEvent o nazwachInventoryUpdated,EquipItemiUseItem. - W ServerStorage wstaw Folder o nazwie
ItemTools. Do środka wstaw Tool o nazwieSword, a do Toola Part o nazwieHandle(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. - Dodawaj skrypty w miarę przechodzenia kroków. Drzewo pokazuje, gdzie idzie każdy z nich.
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:
-- 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:
-- 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,
adddodaje to, co się zmieściło, i zwraca tę liczbę. Wywołuj najpierwspaceFor, gdy potrzebujesz wszystko albo nic, jak robi podnoszenie w kroku 5. removedziała na zasadzie wszystko albo nic. Żądanie 3 jabłek od gracza, który ma 2, niczego nie usuwa i zwracafalse, 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.
| Funkcja | Zwraca | Do czego |
|---|---|---|
add(player, itemId, amount) | Ile dodano | Podnoszenie, nagrody, zakupy |
remove(player, itemId, amount) | true, jeśli usunięto wszystko | Używanie, sprzedaż, crafting |
count(player, itemId) | Suma ze wszystkich stosów | Sprawdzić, co ma gracz |
spaceFor(player, itemId) | Ile jeszcze się zmieści | Sprawdzenie przed dodaniem na zasadzie wszystko albo nic |
getEquipped, setEquipped | Id założonego przedmiotu albo nil | Zakładanie, w kroku 6 |
load, serialize, unload | Kopia 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:
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
GetAsynczwraca 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.
BindToClosezapisuje 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 doSetAsyncwiąż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ć.
- Dodaj Part do Workspace, nazwij go
Applei pomaluj na czerwono. Włącz Anchored i wyłącz CanCollide, żeby nikt w niego nie wpadał, gdy jest niewidoczny. Podpowiedź pokazuje nazwę partu. - Z zaznaczonym partem przewiń okno Properties do sekcji Attributes i kliknij +. Dodaj
ItemIdtypu string i kliknij Save, potem ustaw wartośćapple. Tak samo dodajAmounttypu number z wartością1. - Wstaw Script do partu, nazwij go
ItemPickupi wklej ten kod:
-- 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:
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)
| Żądanie | Klient przysyła | Serwer sprawdza przed działaniem |
|---|---|---|
EquipItem | Id przedmiotu | To 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 |
UseItem | Id przedmiotu | Te 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:
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
- 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ą.
- Kliknij Sword. Miecz pojawi się w twojej ręce i na hotbarze, a jego slot dostanie fioletową ramkę. Kliknij jeszcze raz, żeby go zdjąć.
- Podejdź do partu Apple i użyj jego podpowiedzi. Stos jabłek urośnie do 4, a part zniknie na 15 sekund.
- Żeby sprawdzić leczenie, najpierw zmniejsz zdrowie. Przełącz Client/Server na Server, zaznacz
Humanoidswojej postaci w Explorerze, ustaw Health na 50, przełącz z powrotem na Client i kliknij Apple. - 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (po angielsku). FireClient, OnServerEvent, ograniczenia argumentów i jak wiadomości bez odbiorcy trafiają do kolejki
- Roblox Creator Docs: Securing the client-server boundary (po angielsku). sprawdzanie danych wejściowych remote’ów, sprawdzenia ProximityPrompt i podmiana danych w data store
- Roblox Creator Docs: Data stores (po angielsku). GetAsync, SetAsync i włączanie dostępu ze Studio
- Roblox Creator Docs: Best practices for data stores (po angielsku). jeden klucz na gracza, wzorce kluczy i okresowe zapisy
- Roblox Creator Docs: Data store error codes and limits (po angielsku). limity zapytań na serwer i limit rozmiaru jednej wartości
- Roblox Creator Docs: In-game tools (po angielsku). Handle, kotwiczenie, Backpack i StarterGear
- Roblox Creator Docs: Grid and table layouts (po angielsku). rozmiar komórek UIGridLayout, odstępy i kolejność sortowania
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ą.