Tutorial · Sisteme de joc

Cum să faci un inventar în Roblox Studio

Un inventar pare o problemă de interfață, dar dacă poate fi spart și dacă pierde obiecte decide locul unde se păstrează obiectele. În acest ghid obiectele fiecărui jucător stau într-un tabel pe server, fiecare jucător primește o copie și o desenează ca grilă, echipează un Tool și folosește consumabile prin cereri verificate de server, iar totul se salvează într-un depozit de date.

Actualizat 20 noiembrie 202616 min de cititAutor:

Pe scurt

Ține obiectele fiecărui jucător într-un tabel pe server, într-un ModuleScript din ServerScriptService, și doar acest cod le poate adăuga, scoate și strânge în stive. Descrie obiectele o singură dată într-un ModuleScript din ReplicatedStorage (id, nume, stiva maximă). După fiecare schimbare, serverul îi trimite acelui jucător un RemoteEvent cu o copie a inventarului lui, iar un LocalScript o desenează ca grilă prin ScrollingFrame și UIGridLayout.

  • Clientul nu adaugă niciodată obiecte. Poate doar să ceară, de exemplu "echipează-mi sabia", iar serverul verifică dacă jucătorul o are înainte să facă ceva.
  • Obiectele apar doar prin cod de server pe care îl controlezi: ridicări, cumpărături din magazin după verificarea pe server, recompense.
  • Salvează id-urile obiectelor și cantitățile lor, nu Tool-uri, prin DataStoreService, când jucătorul iese, când serverul se oprește și la câteva minute. Nu salva niciodată un jucător ale cărui date nu s-au încărcat.
Pe această pagină
  1. Cum e construit
  2. De ce obiectele stau pe server
  3. 1. Pregătim Explorer-ul
  4. 2. Catalogul de obiecte
  5. 3. Inventarul pe server
  6. 4. Încărcare și salvare
  7. 5. Ridicarea obiectelor
  8. 6. Echipare și folosire
  9. 7. Grila UI
  10. Verificare
  11. Common errors
  12. Cu RoCode
  13. Întrebări frecvente
  14. Surse și lecturi suplimentare

Cum e construit inventarul

IlustrațieApasă B, treci cu mouse-ul peste un obiect ca să-i citești descrierea, dă clic pe Sword ca s-o iei în mână.

Sistemul e format din șase părți mici, fiecare cu o singură sarcină. Toate regulile despre obiecte trăiesc într-un singur modul de server, așa că atunci când se strică ceva, cauți într-un singur loc.

Părțile sistemului și unde rulează
ParteTip și locSarcină
ItemCatalogModuleScript în ReplicatedStorageCe reprezintă fiecare obiect: nume, descriere, stiva maximă și dacă poate fi echipat sau folosit. Îl citesc serverul și toți clienții.
InventoryServiceModuleScript în ServerScriptServiceȚine sloturile tuturor jucătorilor. Singurul cod care adaugă, scoate și strânge obiecte în stive.
InventoryDataScript în ServerScriptServiceÎncarcă obiectele jucătorului la intrare și le salvează.
InventoryActionsScript în ServerScriptServiceVerifică și execută cererile de echipare și de folosire.
ItemPickupScript într-un PartÎi dă obiectul celui care l-a ridicat.
InventoryClientLocalScript în StarterPlayerScriptsDesenează grila și trimite cererile. Singur nu schimbă nimic.

Datele merg într-o singură direcție. Serverul schimbă inventarul, apoi îi trimite acelui jucător InventoryUpdated cu tot inventarul, iar clientul îl redesenează. Când jucătorul dă clic pe un slot, clientul trimite EquipItem sau UseItem cu id-ul obiectului; serverul verifică cererea, face schimbarea, iar copia nouă vine pe același drum. Să trimiți tot inventarul e mai simplu decât să trimiți schimbările, iar pentru câteva zeci de sloturi mesajul rămâne mic.

De ce clientul nu adaugă niciodată obiecte

E tentant să adaugi obiectul direct în LocalScript-ul care îl afișează: jucătorul a dat clic, slotul s-a umplut. Asta se strică în două feluri.

  • Nimeni altcineva nu vede asta. O schimbare într-un LocalScript există doar pe dispozitivul acelui jucător. Serverul nu află de ea, așa că nu se salvează, iar niciun script de server nu o poate folosi.
  • Oricine o poate falsifica. Dacă repari asta cu un remote ca AddItem(itemId, amount), un trișor va putea declanșa singur acel eveniment, cu orice argumente și de câte ori vrea. Ghidul de securitate Roblox spune că serverul trebuie să verifice tot ce trimite clientul înainte să folosească.

De aceea în acest ghid clientul poate doar să ceară să se facă ceva cu obiectele pe care jucătorul le are deja: "echipează asta" și "folosește asta". Fiecare cerere are un singur id de obiect și nicio cantitate, iar pe server trece printr-o singură verificare: e un șir, obiectul există, jucătorul are cel puțin unul și nu trimite mai mult de patru cereri pe secundă. Apoi serverul găsește singur Tool-ul după catalog. Nu acceptă niciodată de la client un Tool, o cale sau un instance, lucru despre care avertizează același ghid.

Obiectele ajung în inventar doar prin cod de server: o ridicare verificată de server, o cumpărare pentru care serverul a încasat banii (o construiește ghidul despre magazin), o recompensă de quest sau un drop. Despre remote-uri în general, cu verificarea altor tipuri de argumente, citește în ghidul despre RemoteEvent.

Pasul 1: pregătește Explorer-ul

Creează aceste obiecte manual. Scripturile din pașii următori le caută după nume, așa că scrie fiecare nume exact ca aici.

  1. În ReplicatedStorage inserează un Folder numit InventoryRemotes. În el inserează trei RemoteEvent-uri numite InventoryUpdated, EquipItem și UseItem.
  2. În ServerStorage inserează un Folder numit ItemTools. În el inserează un Tool numit Sword, iar în Tool un Part numit Handle (1 pe 4 pe 1 studs e foarte bine). Verifică dacă Anchored e debifat la Handle: Roblox avertizează că personajul rămâne blocat pe loc dacă ține un instrument cu part-uri ancorate. Merge și un Tool pe care îl ai deja, dacă numele lui se potrivește cu catalogul de la pasul 2.
  3. Adaugă scripturile pe măsură ce parcurgi pașii. Arborele arată unde merge fiecare.
Explorer-ul după ce ai terminat ghidul
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

Pasul 2: descrie obiectele în catalog

Catalogul descrie o singură dată fiecare obiect care poate exista. Inventarele păstrează apoi doar id-ul obiectului și cantitatea. Așa salvările rămân mici, iar mai târziu poți redenumi un obiect sau îi poți rescrie descrierea fără să atingi datele salvate ale nimănui.

Inserează un ModuleScript în ReplicatedStorage, numește-l ItemCatalog și înlocuiește-i conținutul cu asta:

ModuleScript în ReplicatedStorage cu numele ItemCatalog
-- Toate obiectele care pot exista în joc. Lista asta o citesc serverul și toți
-- clienții; doar serverul decide cine ce are.
export type Item = {
	id: string, -- trebuie să se potrivească cu cheia de mai jos
	name: string,
	description: string,
	maxStack: number, -- câte bucăți din acest obiect încap într-un slot
	icon: string?, -- imagine opțională: "rbxassetid://" plus ID-ul imaginii tale
	toolName: string?, -- Tool în ServerStorage.ItemTools: obiectul se poate echipa
	heal: number?, -- câtă viață reface: obiectul e consumabil
}

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 = {}

-- Returnează obiectul cu acest id sau nil dacă nu există un astfel de obiect
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Câmpurile opționale decid ce face obiectul. toolName îl face echipabil, heal îl face utilizabil, iar un obiect fără niciunul, ca lemnul, stă în inventar până îl scoate alt cod de server (crafting, vânzare).

Ca să adaugi un obiect, adaugă o intrare la care cheia și id-ul coincid. Id-urile țin cont de majuscule și tocmai ele se salvează, așa că nu schimba niciodată un id când obiectul e deja la jucători: schimbă-i name-ul.

Pasul 3: ține inventarele pe server

Acest ModuleScript deține inventarul fiecărui jucător. Fiecare inventar e o listă de sloturi, fiecare slot cu un id de obiect și o cantitate, plus o capacitate de 20 de sloturi. Alte scripturi de server îi apelează funcțiile și nimeni altcineva nu editează tabelul.

Inserează un ModuleScript în ServerScriptService și numește-l InventoryService:

ModuleScript în ServerScriptService cu numele InventoryService
-- Singurul cod care schimbă inventarele. Stă în ServerScriptService,
-- unde clienții nu-l pot nici vedea, nici rula.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Modul strict nu vede ce returnează require prin WaitForChild, așa că
-- descriem partea din modul pe care o folosește acest script
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 -- sloturi pe jucător
local STARTER_ITEMS: { Slot } = { -- cu ce începe un jucător complet nou
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Îi trimite proprietarului o copie a inventarului lui. Se apelează după fiecare schimbare.
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

-- Regulile stivelor: întâi completăm stivele incomplete, apoi începem stive noi
-- în sloturile goale. Returnează câte s-au adăugat, poate fi mai puțin decât s-a cerut.
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

-- Câte bucăți din obiect mai încap: locul din stivele lui plus sloturile goale
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

-- Adaugă până la amount bucăți din obiect. Returnează câte s-au adăugat (0 dacă
-- obiectul nu există, inventarul e plin sau încă nu s-a încărcat).
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

-- Scoate exact amount bucăți din obiect, începând cu ultimele stive.
-- Dacă jucătorul are mai puține, nu scoate nimic și returnează 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
	-- Mergem de la capăt, ca table.remove să nu sară peste sloturi
	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

-- Se apelează când datele salvate ale jucătorului s-au încărcat. saved e ce
-- a returnat depozitul de date: nil pentru un jucător nou. Fiecare intrare trece din nou prin
-- regulile stivelor, așa că obiectele șterse și mărimile vechi ale stivelor nu strică nimic.
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

-- O copie simplă pentru salvare sau nil dacă datele jucătorului nu s-au încărcat niciodată
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

Rândurile type și conversia :: de după require îi trebuie doar verificatorului de tipuri Luau, care nu vede ce returnează un modul găsit prin WaitForChild. În timpul jocului nu schimbă nimic. Celelalte scripturi din acest ghid fac la fel.

Cum funcționează regulile stivelor cu catalogul de mai sus, unde merele se strâng în stive de până la 10:

  • Dacă adaugi 15 mere unui jucător cu o stivă de 7, stiva aceea se umple până la 10, apoi începe o stivă nouă de 5.
  • Când se termină sloturile, add adaugă ce a încăput și returnează acel număr. Apelează întâi spaceFor când vrei totul sau nimic, cum face ridicarea de la pasul 5.
  • remove funcționează pe principiul totul sau nimic. Cererea a 3 mere de la un jucător care are 2 nu scoate nimic și returnează false, așa că verifică rezultatul înainte să dai ceva în schimb.
  • Sloturile nu au goluri: când un slot se golește, celelalte urcă. Așa lista e mai ușor de trimis și de salvat. Despre sloturile care își păstrează poziția vorbim în întrebările de la final.
Ce pot apela alte scripturi de server
FuncțieReturneazăPentru ce
add(player, itemId, amount)Câte s-au adăugatRidicări, recompense, cumpărături
remove(player, itemId, amount)true dacă s-a scos totFolosire, vânzare, crafting
count(player, itemId)Suma din toate stiveleSă verifici ce are jucătorul
spaceFor(player, itemId)Câte mai încapVerificare înainte de o adăugare totul-sau-nimic
getEquipped, setEquippedId-ul obiectului echipat sau nilEchipare, la pasul 6
load, serialize, unloadO copie gata de salvare (serialize)Încărcare și salvare, la pasul 4

Pasul 4: încarcă și salvează fiecare inventar

Inventarele trăiesc în memoria serverului, așa că dispar când jucătorul iese. Acest script încarcă sloturile jucătorului din depozitul de date când intră și le scrie înapoi când iese, când serverul se oprește și la fiecare trei minute, pentru cazul unei căderi a serverului. Salvează doar id-urile obiectelor și cantitățile: depozitele de date nu pot păstra un Instance, de exemplu un Tool.

Inserează un Script în ServerScriptService și numește-l InventoryData:

Script în ServerScriptService cu numele 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

-- Se salvează doar jucătorii ale căror date s-au încărcat. După o încărcare eșuată
-- nu ai voie să salvezi, altfel un inventar gol îl înlocuiește pe cel real.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- O singură cerere eșuată nu trebuie să coste pe nimeni obiecte, așa că încercăm de câteva ori.
-- Și GetDataStore e în pcall, așa că o sesiune Studio fără acces la depozitele
-- de date primește un avertisment în loc să oprească acest script.
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 -- jucătorul a ieșit cât încărcam
	end
	if ok then
		InventoryService.load(player, saved) -- saved e nil pentru un jucător nou
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- De obicei înseamnă că accesul Studio la API services e dezactivat. Jucăm cu
		-- obiectele de start, ca să se poată testa, dar nu le salvăm niciodată.
		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 -- datele nu s-au încărcat niciodată, nu e nimic sigur de scris
	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)

-- Când serverul se oprește, îi salvăm pe toți cei încă aici și așteptăm fiecare
-- salvare în curs, inclusiv cele pornite de PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Îi salvăm pe toți la câteva minute, ca o cădere a serverului să coste minute, nu toată sesiunea
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Ce face scriptul și de ce:

  • Încărcare cu valori implicite. Un jucător nou nu are o valoare salvată, așa că GetAsync returnează nil și primește obiectele de start. Sloturile salvate trec din nou prin regulile stivelor, așa că un obiect scos din catalog sau o stivă maximă micșorată nu strică încărcarea. Tot ce nu mai încape sau al cărui id nu mai e în catalog se aruncă, iar următoarea salvare face asta definitiv, așa că ține în catalog fiecare id pe care îl pot avea jucătorii.
  • Nu salva niciodată după o încărcare eșuată. Se scriu doar jucătorii din canSave. Pe un server live, jucătorului ale cărui date nu s-au încărcat nici după trei încercări i se cere să reintre. În Studio primește în schimb obiecte de start nesalvabile, cu câteva secunde mai târziu din cauza reîncercărilor. Așa va fi până când place-ul e publicat cu accesul la API activat.
  • Salvare la ieșire și la oprire. BindToClose îi salvează pe toți cei rămași pe server și așteaptă salvările deja în curs. Roblox le dă funcțiilor legate până la 30 de secunde.
  • Să nu treci de limite. O scriere pe jucător la fiecare trei minute plus una la ieșire înseamnă mult mai puțin decât bugetul standard al serverului de 60 de scrieri pe minut plus 40 pentru fiecare jucător (conform documentației la 30 septembrie 2026). Tiparul de cheie User_ e luat din recomandările Roblox, iar transmiterea user ID-ului în SetAsync leagă datele de acel jucător, lucru pe care Roblox îl recomandă insistent pentru tratarea cererilor de ștergere a datelor.

Pentru un joc mic, e o bază solidă. Blocarea sesiunii, care împiedică un jucător ce a schimbat repede serverul să-și încarce datele înainte ca serverul vechi să le fi salvat, și când să folosești UpdateAsync în loc de SetAsync sunt explicate în tutorialul DataStore.

Pasul 5: dă obiecte din lume

Ridicarea e cel mai simplu mod prin care obiectele ajung în inventar: un part cu un ProximityPrompt care adaugă obiectul când jucătorul îl folosește. Scriptul îi ascultă evenimentul Triggered pe server, așa că obiectul se adaugă acolo unde clientul nu poate interveni.

  1. Adaugă un Part în Workspace, numește-l Apple și colorează-l în roșu. Activează Anchored și dezactivează CanCollide, ca nimeni să nu se lovească de el cât e invizibil. Promptul arată numele part-ului.
  2. Cu part-ul selectat, derulează fereastra Properties până la secțiunea Attributes și apasă +. Adaugă ItemId de tip string și apasă Save, apoi dă-i valoarea apple. La fel adaugă Amount de tip number cu valoarea 1.
  3. Inserează un Script în part, numește-l ItemPickup și lipește acest cod:
Script în part-ul Apple din Workspace cu numele ItemPickup
-- Pune acest Script într-un Part și dă-i Part-ului două atribute:
-- ItemId (șir, de exemplu apple) și Amount (număr, de exemplu 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 -- altcineva tocmai l-a ridicat
	end
	-- Verificăm distanța pe server, nu avem încredere în cerere
	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 -- nu e destul loc: lăsăm obiectul pe loc
	end
	InventoryService.add(player, itemId, amount)

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

Copiază part-ul ca să pui mai multe obiecte. Schimbă atributele ca să dai lemn, încă o sabie sau o stivă de mere.

Roblox verifică distanța pentru Triggered, dar ghidul lui de securitate spune totuși să verifici prompturile pe server: un trișor poate declanșa evenimentele promptului chiar și când Enabled e false și poate trage un part neancorat spre personajul lui. De aceea scriptul verifică singur Enabled și distanța, și de aceea part-ul e ancorat.

Orice alt script de server dă obiecte la fel. După o cumpărare, un quest sau o eliminare, include InventoryService prin require, ca scripturile de mai sus, și apelează InventoryService.add(player, "wood", 5). Verifică întâi spaceFor când obiectul nu are voie să se piardă. O altă sursă poate fi un NPC: în ghidul despre dialoguri cu NPC-uri un răspuns declanșează o acțiune pe server, iar acea acțiune poate apela la fel InventoryService.add.

Pasul 6: echiparea unui Tool și folosirea obiectelor

Două RemoteEvent-uri poartă singurele cereri pe care le poate face clientul. EquipItem pune o copie a Tool-ului obiectului din ServerStorage în Backpack-ul jucătorului (hotbar-ul din partea de jos a ecranului) și în mâna lui, iar o nouă cerere o scoate. UseItem scoate o bucată dintr-un obiect utilizabil și îi aplică efectul, aici vindecarea.

Inserează un Script în ServerScriptService și numește-l InventoryActions:

Script în ServerScriptService cu numele 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 } = {}

-- Fiecare cerere începe aici. Clientul poate trimite orice oricând, așa că
-- verificăm tipul, dacă obiectul există, dacă jucătorul îl are și frecvența.
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

-- Distruge Tool-ul acestui obiect oriunde ar fi copia: hotbar, mână sau 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) -- un singur instrument echipat odată

	local tool = template:Clone()
	tool.CanBeDropped = false -- o copie aruncată ar putea-o ridica altcineva
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- A doua copie din StarterGear se copiază înapoi în Backpack după respawn
	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) -- direct în mână
	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) -- un nou clic pe obiectul echipat îl scoate
	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 -- mort sau deja cu viața plină: nu consumăm obiectul
	end
	-- Întâi luăm obiectul și vindecăm doar dacă asta a reușit
	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)
Ce e permis fiecărei cereri
CerereClientul trimiteServerul verifică înainte de acțiune
EquipItemId-ul obiectuluiE un șir, obiectul există, jucătorul îl are, cererile vin de cel mult patru ori pe secundă, obiectul are toolName, iar un Tool cu acest nume stă în ServerStorage.ItemTools
UseItemId-ul obiectuluiAceleași verificări de tip, proprietate și frecvență, obiectul are o valoare heal, personajul e viu și rănit, iar un obiect e scos înainte să se adauge viață

Trei detalii împiedică dublarea sau pierderea unui Tool. Copia are CanBeDropped setat la false, pentru că un Tool aruncat cade în Workspace, de unde îl poate lua alt jucător, iar originalul rămâne în inventar. Fiecare copie poartă atributul InventoryItem, așa că la dezechipare poți găsi și distruge fiecare copie, oriunde ar fi. Iar dacă jucătorul are un container StarterGear, în el se pune o a doua copie. Roblox copiază StarterGear în Backpack la fiecare apariție a personajului, așa că sabia echipată revine după respawn.

E echipat un singur Tool odată, iar echiparea nu se salvează, așa că după reintrare jucătorul începe cu hotbar-ul gol. Dacă adaugi mai târziu vânzarea sau aruncarea, dezechipează obiectul înainte ca ultima lui copie să plece din inventar.

Sabia provizorie o poți transforma într-o sabie care chiar luptă: construiește un Tool după ghidul despre sabie, lasă-i numele Sword și pune-l în ItemTools în locul celei provizorii. Scriptul de server din acel ghid va verifica fiecare lovitură, indiferent cum a primit jucătorul sabia.

Pasul 7: desenează grila inventarului

LocalScript-ul construiește toată fereastra în cod, așa că nu trebuie așezat nimic manual. Un ScrollingFrame ține sloturile, un UIGridLayout din el le așază pe rânduri, iar AutomaticCanvasSize mărește zona derulabilă pe măsură ce se adaugă rânduri.

În Explorer deschide StarterPlayer, inserează un LocalScript în StarterPlayerScripts și numește-l InventoryClient:

LocalScript în StarterPlayerScripts cu numele 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. Construim fereastra o singură dată. ResetOnSpawn = false o păstrează după respawn.
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 o mărește după celule
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. O celulă pe slot. Asta doar desenează ce a trimis serverul; inventarul
-- însuși nu se schimbă niciodată de aici.
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 -- slot gol
	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()
		-- Cerem, nu ordonăm: serverul verifică cererea și trimite rezultatul
		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

-- Serverul trimite asta după încărcare și după fiecare schimbare
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Deschidem și închidem cu butonul sau cu tasta 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)

Un LocalScript din StarterPlayerScripts rulează o dată pe sesiune, iar ResetOnSpawn = false păstrează ScreenGui-ul la respawn-ul personajului, așa că grila arată în continuare ultima copie trimisă de server.

Clientul desenează câte o celulă pentru fiecare slot, inclusiv cele goale, așa că un inventar de 20 de sloturi arată mereu ca 20 de sloturi. Fiecare actualizare distruge celulele vechi și construiește altele noi, ceea ce e simplu și potrivit pentru câteva zeci de sloturi. Dacă serverul trimite InventoryUpdated înainte ca acest script să se fi conectat la el, Roblox pune mesajul la coadă și îl livrează imediat ce se conectează handler-ul, așa că primul inventar nu se pierde.

Vrei să desenezi fereastra în Studio? Construiește un ScreenGui cu un slot-șablon și fă-i Clone în makeCell. Pentru iconițe dă-i obiectului din catalog un icon cu o imagine încărcată de tine, iar celula lui va arăta imaginea în loc de nume.

Verifică inventarul

  1. Apasă Play. Deschide inventarul cu butonul din stânga sau cu tasta B: un jucător nou are Sword și 3 Apple, iar contorul arată 2 / 20 slots. Cât timp Studio nu poate accesa depozitele de date, obiectele apar după câteva secunde, după avertismentele de încărcare din Output, și nu se salvează.
  2. Dă clic pe Sword. Sabia apare în mâna ta și în hotbar, iar slotul ei primește un chenar mov. Dă clic din nou ca s-o scoți.
  3. Mergi la part-ul Apple și folosește-i promptul. Stiva de mere crește la 4, iar part-ul dispare pentru 15 secunde.
  4. Ca să verifici vindecarea, scade întâi viața. Comută Client/Server pe Server, selectează Humanoid-ul personajului tău în Explorer, setează Health la 50, comută înapoi pe Client și dă clic pe Apple.
  5. Cu accesul Studio la API services activat, oprește jocul și pornește-l din nou. Mărul ridicat e la locul lui. Dacă încărcarea sau salvarea a eșuat, Output îți spune.

Ca să verifici cu mai mulți jucători, alege în setările de test Server & Clients cu 2 clienți. Fiecare jucător își vede doar propriul inventar, iar sabia din mâna celuilalt o văd amândoi.

Erori frecvente și soluții

Cele mai multe probleme se văd în fereastra Output ca avertisment sau rând roșu de eroare. Citește-l pe primul: erorile următoare decurg adesea din el.

Infinite yield possible la un apel WaitForChild

Scriptul așteaptă un obiect care nu există sub exact acest nume. Compară Explorer-ul tău cu arborele de la pasul 1: InventoryRemotes cu trei RemoteEvent-uri în ReplicatedStorage, ItemTools în ServerStorage și cele două module. Numele țin cont de majuscule. Ghidul despre erorile din scripturi explică acest avertisment mai pe larg.

Grila se deschide, dar rămâne goală

Clientul desenează doar ce trimite serverul. Caută în Output avertismente Inventory load failed și verifică dacă InventoryData e un Script, nu un LocalScript, în ServerScriptService, cu ModuleScript-ul InventoryService alături. Dacă Output arată o eroare Remote event invocation, pe client nu ascultă nimeni InventoryUpdated: caută o eroare anterioară de la InventoryClient.

Obiectele se resetează de fiecare dată când joc în Studio

Dacă Output scrie Inventory not loaded: playing with starter items that will not be saved, place-ul nu e publicat sau accesul Studio la API services e dezactivat. Activează-l cum e descris la pasul 4, într-o copie de test a jocului tău.

Clicul pe sabie nu face nimic

Caută în Output Cannot equip sword: Tool-ul din ServerStorage.ItemTools trebuie să se numească exact ca toolName din catalog. În plus, Tool-ul are nevoie de un part numit Handle ca să poată fi ținut, dacă nu i-ai setat RequiresHandle la false.

Promptul de ridicare apare, dar nu se adaugă nimic

Atributul ItemId trebuie să se potrivească exact cu id-ul din catalog, inclusiv majusculele: apple, nu Apple. Nu se adaugă nimic cât inventarul jucătorului încă se încarcă sau când nu e loc pentru toată cantitatea.

Salvarea se strică după ce am schimbat ce se salvează

Depozitele de date acceptă date simple: șiruri, numere, valori booleene și tabele din ele. Salvarea unui Tool, Part sau a oricărui alt Instance eșuează sau valoarea se salvează ca nil. Salvează id-ul obiectului și cantitatea, iar tot restul refă-l din catalog, cum face serialize.

Fă-o cu RoCode

Dacă îți e mai ușor să descrii sistemul decât să-l construiești manual, RoCode îl poate construi în place-ul pe care îl ai deschis. E un agent AI pentru Roblox Studio: descrii funcția în chatul web, iar pluginul lui pentru Studio creează scripturile și obiectele în Explorer-ul tău, în loc să-ți dea cod de lipit.

Tu scrii

Adaugă un inventar de 20 de sloturi cu stive de obiecte, o grilă UI care se deschide pe B, o sabie din ServerStorage pe care jucătorii o pot echipa, mere care vindecă și salvare prin DataStoreService.

RoCode face
  • Poate să se uite prin place-ul tău când un pas o cere, prin Search Game și Search Scripts, ca să se sprijine pe obiectele, remote-urile sau codul de salvare existente, nu să adauge un al doilea sistem
  • Creează folderele și RemoteEvent-urile prin Create Instance, iar ModuleScript-urile, Script-urile și LocalScript-urile prin Create Script
  • Poate construi o schiță a ferestrei prin Build UI, unde există un layout de inventar cu sloturi provizorii; codul care umple sloturile de pe server se scrie în scripturi separate
  • Verifică în Studio compilarea fiecărui script prin Check Script, care prinde erorile de compilare și câteva tipare riscante, dar nu verifică tipurile, nu face lint și nu îți rulează codul

Fiecare lot de modificări e un punct de anulare în Studio. RoCode nu poate activa accesul Studio la API services, asta o faci tu. Cu pluginul 3.9 sau mai nou poate porni un playtest scurt și citi erorile, iar cu pluginul 3.9.15 sau mai nou personajul lui de test poate apăsa taste și echipa obiecte, dar verifică doar ce a hotărât el să testeze, așa că verifică singur salvarea printr-un playtest. Inventarul stă peste alte sisteme, precum salvarea și instrumentele, iar creatorul de jocuri AI care construiește în propriul tău place din Studio le adaugă câte un prompt odată. Cum se conectează RoCode la Studio.

Întrebări frecvente

Să folosesc Backpack-ul din Roblox în loc de propriul inventar?

Backpack-ul e inventarul integrat al Roblox: fiecare Tool din el apare ca buton în hotbar. Dacă toate obiectele din jocul tău sunt Tool-uri și nu ai nevoie de stive, cantități și o limită de sloturi, s-ar putea să-ți ajungă, deși tot va trebui să salvezi ce Tool-uri are fiecare jucător. Un inventar propriu îți trebuie pentru obiectele care nu sunt Tool-uri, de exemplu materiale și consumabile. Ghidul acesta le folosește pe amândouă: inventarul păstrează tot, iar Backpack-ul ține Tool-ul echipat.

Cum ascund hotbar-ul standard din Roblox?

Dintr-un LocalScript apelează StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Când hotbar-ul e ascuns, jucătorii au nevoie de alt mod de a lua și a scoate Tool-ul echipat, de exemplu un buton care îi cere serverului să apeleze Humanoid:EquipTool sau Humanoid:UnequipTools.

Cum fac sloturile să-și păstreze poziția pentru drag and drop?

Ține o listă de lungime fixă cu câte o intrare pe slot și marchează sloturile goale cu o valoare precum un id gol, nu cu nil, pentru că Roblox nu recomandă trimiterea tabelelor cu nil printr-un RemoteEvent. Apoi adaugă un RemoteEvent MoveItem care trimite două numere de slot și lasă serverul să verifice că ambele sunt întregi de la 1 la capacitate înainte să le schimbe între ele.

Cât de mare poate fi un inventar salvat?

O valoare dintr-un depozit de date poate avea până la 4 194 304 caractere după serializare (conform documentației la 30 septembrie 2026). O listă de id-uri și cantități ocupă o parte infimă din asta. Mărimea salvării o crește textul pentru fiecare obiect, de exemplu nume proprii sau descrieri lungi salvate pentru fiecare obiect.

Cum cumpăr și vând obiecte pe monede?

Fă totul pe server. Ca să vinzi, apelează InventoryService.remove și plătește doar dacă a returnat true. Ca să cumperi, verifică prețul și spaceFor, ia monedele, apoi apelează add. Ghidul despre magazin construiește partea de cumpărare.

Surse și lecturi suplimentare

Cum a fost verificat codul: fiecare script de pe această pagină trece printr-o verificare strictă a tipurilor Luau cu definițiile API Roblox (luau-lsp, 20 noiembrie 2026). Verificarea tipurilor prinde nume greșite de API și tipuri greșite, dar nu și greșelile de logică a jocului, așa că testează totul în Studio înainte să publici.

Încearcă RoCode în jocul tău.

Credite gratuite în fiecare zi, fără card. Instalează pluginul, descrie o funcție și verifică ce a apărut în Studio.