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ă
Cum e construit inventarul
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.
| Parte | Tip și loc | Sarcină |
|---|---|---|
ItemCatalog | ModuleScript în ReplicatedStorage | Ce reprezintă fiecare obiect: nume, descriere, stiva maximă și dacă poate fi echipat sau folosit. Îl citesc serverul și toți clienții. |
InventoryService | ModuleScript în ServerScriptService | Ține sloturile tuturor jucătorilor. Singurul cod care adaugă, scoate și strânge obiecte în stive. |
InventoryData | Script în ServerScriptService | Încarcă obiectele jucătorului la intrare și le salvează. |
InventoryActions | Script în ServerScriptService | Verifică și execută cererile de echipare și de folosire. |
ItemPickup | Script într-un Part | Îi dă obiectul celui care l-a ridicat. |
InventoryClient | LocalScript în StarterPlayerScripts | Desenează 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.
- În ReplicatedStorage inserează un Folder numit
InventoryRemotes. În el inserează trei RemoteEvent-uri numiteInventoryUpdated,EquipItemșiUseItem. - În ServerStorage inserează un Folder numit
ItemTools. În el inserează un Tool numitSword, iar în Tool un Part numitHandle(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. - Adaugă scripturile pe măsură ce parcurgi pașii. Arborele arată unde merge fiecare.
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:
-- 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:
-- 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,
addadaugă ce a încăput și returnează acel număr. Apelează întâispaceForcând vrei totul sau nimic, cum face ridicarea de la pasul 5. removefuncț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.
| Funcție | Returnează | Pentru ce |
|---|---|---|
add(player, itemId, amount) | Câte s-au adăugat | Ridicări, recompense, cumpărături |
remove(player, itemId, amount) | true dacă s-a scos tot | Folosire, vânzare, crafting |
count(player, itemId) | Suma din toate stivele | Să verifici ce are jucătorul |
spaceFor(player, itemId) | Câte mai încap | Verificare înainte de o adăugare totul-sau-nimic |
getEquipped, setEquipped | Id-ul obiectului echipat sau nil | Echipare, la pasul 6 |
load, serialize, unload | O 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:
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ă
GetAsyncreturnează 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 înSetAsyncleagă 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.
- 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. - Cu part-ul selectat, derulează fereastra Properties până la secțiunea Attributes și apasă +. Adaugă
ItemIdde tip string și apasă Save, apoi dă-i valoareaapple. La fel adaugăAmountde tip number cu valoarea1. - Inserează un Script în part, numește-l
ItemPickupși lipește acest cod:
-- 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:
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)
| Cerere | Clientul trimite | Serverul verifică înainte de acțiune |
|---|---|---|
EquipItem | Id-ul obiectului | E 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 |
UseItem | Id-ul obiectului | Aceleaș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:
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
- 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ă.
- 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.
- Mergi la part-ul Apple și folosește-i promptul. Stiva de mere crește la 4, iar part-ul dispare pentru 15 secunde.
- 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. - 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.
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.
- 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
- Roblox Creator Docs: Remote events and callbacks (în engleză). FireClient, OnServerEvent, limitările argumentelor și cum intră la coadă mesajele fără destinatar
- Roblox Creator Docs: Securing the client-server boundary (în engleză). verificarea datelor de intrare ale remote-urilor, verificările ProximityPrompt și falsificarea datelor din depozit
- Roblox Creator Docs: Data stores (în engleză). GetAsync, SetAsync și activarea accesului din Studio
- Roblox Creator Docs: Best practices for data stores (în engleză). o cheie pe jucător, tipare de chei și salvări periodice
- Roblox Creator Docs: Data store error codes and limits (în engleză). limitele de cereri pe server și limita de mărime a unei valori
- Roblox Creator Docs: In-game tools (în engleză). Handle, ancorare, Backpack și StarterGear
- Roblox Creator Docs: Grid and table layouts (în engleză). mărimea celulelor UIGridLayout, spațierea și ordinea de sortare
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.