Tutorial · Συστήματα παιχνιδιού

Πώς να φτιάξεις inventory στο Roblox Studio

Το inventory μοιάζει με δουλειά για το interface, αλλά το αν μπορεί να χακαριστεί και αν χάνει αντικείμενα το αποφασίζει το σημείο όπου κρατιούνται τα αντικείμενα. Σε αυτόν τον οδηγό τα αντικείμενα κάθε παίκτη βρίσκονται σε ένα table στον server, κάθε παίκτης παίρνει ένα αντίγραφο και το σχεδιάζει ως πλέγμα, εξοπλίζει Tools και χρησιμοποιεί αναλώσιμα με αιτήματα που ελέγχει ο server, και όλα αποθηκεύονται σε data store.

Ενημερώθηκε 20 Νοεμβρίου 202617 λεπτά ανάγνωσηςΣυντάκτης:

Με λίγα λόγια

Κρατήστε τα αντικείμενα κάθε παίκτη σε ένα table στον server, μέσα σε ένα ModuleScript στο ServerScriptService, και μόνο αυτός ο κώδικας μπορεί να τα προσθέτει, να τα αφαιρεί και να τα βάζει σε stacks. Περιγράψτε τα αντικείμενα μία φορά σε ένα ModuleScript στο ReplicatedStorage (id, όνομα, μέγιστο stack). Μετά από κάθε αλλαγή ο server στέλνει σε αυτόν τον παίκτη ένα RemoteEvent με αντίγραφο του inventory του, και ένα LocalScript το σχεδιάζει ως πλέγμα με ScrollingFrame και UIGridLayout.

  • Ο client δεν προσθέτει ποτέ αντικείμενα. Μπορεί μόνο να ζητήσει, για παράδειγμα "εξόπλισε το σπαθί μου", και ο server ελέγχει ότι ο παίκτης το έχει πριν κάνει οτιδήποτε.
  • Τα αντικείμενα εμφανίζονται μόνο μέσω κώδικα server που ελέγχετε εσείς: μάζεμα, αγορές στο μαγαζί μετά από έλεγχο στον server, ανταμοιβές.
  • Αποθηκεύετε τα id των αντικειμένων και την ποσότητά τους, όχι τα Tools, μέσω DataStoreService, όταν ο παίκτης φεύγει, όταν κλείνει ο server και κάθε λίγα λεπτά. Μην αποθηκεύετε ποτέ έναν παίκτη του οποίου τα δεδομένα δεν φόρτωσαν.
Σε αυτή τη σελίδα
  1. Πώς είναι στημένο
  2. Γιατί τα αντικείμενα στον server
  3. 1. Ετοιμάζουμε το Explorer
  4. 2. Κατάλογος αντικειμένων
  5. 3. Inventory στον server
  6. 4. Φόρτωση και αποθήκευση
  7. 5. Μάζεμα αντικειμένων
  8. 6. Εξοπλισμός και χρήση
  9. 7. Πλέγμα UI
  10. Δοκιμή
  11. Common errors
  12. Με το RoCode
  13. Συχνές ερωτήσεις
  14. Πηγές και περαιτέρω ανάγνωση

Πώς είναι στημένο το inventory

ΕικονογράφησηΠατήστε B, περάστε τον δείκτη πάνω από ένα αντικείμενο για να διαβάσετε την περιγραφή, κάντε κλικ στο Sword για να το πάρετε στο χέρι.

Το σύστημα αποτελείται από έξι μικρά κομμάτια, και το καθένα έχει μία δουλειά. Όλοι οι κανόνες για τα αντικείμενα ζουν σε ένα module στον server, οπότε όταν κάτι χαλάσει, ψάχνετε σε ακριβώς ένα σημείο.

Τα κομμάτια του συστήματος και πού τρέχουν
ΚομμάτιΤύπος και θέσηΔουλειά
ItemCatalogModuleScript στο ReplicatedStorageΤι είναι κάθε αντικείμενο: όνομα, περιγραφή, μέγιστο stack και αν μπορεί να εξοπλιστεί ή να χρησιμοποιηθεί. Το διαβάζουν ο server και όλοι οι clients.
InventoryServiceModuleScript στο ServerScriptServiceΚρατά τα slots όλων των παικτών. Ο μόνος κώδικας που προσθέτει, αφαιρεί και βάζει αντικείμενα σε stacks.
InventoryDataScript στο ServerScriptServiceΦορτώνει τα αντικείμενα του παίκτη όταν μπαίνει και τα αποθηκεύει.
InventoryActionsScript στο ServerScriptServiceΕλέγχει και εκτελεί τα αιτήματα εξοπλισμού και χρήσης.
ItemPickupScript μέσα σε PartΔίνει το αντικείμενο σε όποιον το μάζεψε.
InventoryClientLocalScript στο StarterPlayerScriptsΣχεδιάζει το πλέγμα και στέλνει αιτήματα. Το ίδιο δεν αλλάζει τίποτα.

Τα δεδομένα πάνε προς μία κατεύθυνση. Ο server αλλάζει το inventory, μετά στέλνει σε αυτόν τον παίκτη το InventoryUpdated με όλο το inventory, και ο client το ξανασχεδιάζει. Όταν ο παίκτης κάνει κλικ σε ένα slot, ο client στέλνει EquipItem ή UseItem με το id του αντικειμένου· ο server ελέγχει το αίτημα, κάνει την αλλαγή, και το νέο αντίγραφο έρχεται από τον ίδιο δρόμο. Η αποστολή όλου του inventory είναι πιο απλή από την αποστολή αλλαγών, και για μερικές δεκάδες slots το μήνυμα μένει μικρό.

Γιατί ο client δεν προσθέτει ποτέ αντικείμενα

Είναι δελεαστικό να προσθέσετε ένα αντικείμενο κατευθείαν στο LocalScript που το δείχνει: ο παίκτης έκανε κλικ, το slot γέμισε. Αυτό χαλάει με δύο τρόπους.

  • Κανείς άλλος δεν το βλέπει. Μια αλλαγή σε LocalScript υπάρχει μόνο στη συσκευή αυτού του παίκτη. Ο server δεν το μαθαίνει, οπότε δεν αποθηκεύεται, και κανένα server script δεν μπορεί να το χρησιμοποιήσει.
  • Μπορεί να το πλαστογραφήσει οποιοσδήποτε. Αν το διορθώσετε με ένα remote όπως AddItem(itemId, amount), ένας cheater μπορεί να καλεί μόνος του αυτό το event, με όποια ορίσματα θέλει και όσες φορές θέλει. Ο οδηγός ασφαλείας της Roblox λέει ότι ο server πρέπει να ελέγχει ό,τι στέλνει ο client πριν το χρησιμοποιήσει.

Γι' αυτό σε αυτόν τον οδηγό ο client μπορεί μόνο να ζητά κάτι να γίνει με αντικείμενα που ο παίκτης έχει ήδη: "εξόπλισε αυτό" και "χρησιμοποίησε αυτό". Κάθε αίτημα έχει ένα id αντικειμένου και καμία ποσότητα, και στον server περνά έναν έλεγχο: είναι string, το αντικείμενο υπάρχει, ο παίκτης έχει τουλάχιστον ένα, και ο παίκτης στέλνει το πολύ τέσσερα αιτήματα το δευτερόλεπτο. Μετά ο server βρίσκει μόνος του το Tool από τον κατάλογο. Δεν δέχεται ποτέ από τον client Tool, διαδρομή ή instance, για το οποίο προειδοποιεί ο ίδιος οδηγός.

Τα αντικείμενα μπαίνουν στο inventory μόνο μέσω κώδικα server: μάζεμα που έλεγξε ο server, αγορά για την οποία ο server αφαίρεσε τα χρήματα (τη στήνει ο οδηγός για το μαγαζί), ανταμοιβή από quest ή drop. Για τα remotes γενικά, με έλεγχο και άλλων ειδών ορισμάτων, διαβάστε τον οδηγό για το RemoteEvent.

Βήμα 1: ετοιμάστε το Explorer

Φτιάξτε αυτά τα αντικείμενα με το χέρι. Τα scripts των επόμενων βημάτων τα ψάχνουν με το όνομα, οπότε γράψτε κάθε όνομα ακριβώς όπως εδώ.

  1. Στο ReplicatedStorage βάλτε ένα Folder με όνομα InventoryRemotes. Μέσα βάλτε τρία RemoteEvent με ονόματα InventoryUpdated, EquipItem και UseItem.
  2. Στο ServerStorage βάλτε ένα Folder με όνομα ItemTools. Μέσα βάλτε ένα Tool με όνομα Sword, και στο Tool ένα Part με όνομα Handle (1 επί 4 επί 1 stud αρκεί). Ελέγξτε ότι το Anchored του Handle είναι ξετσεκαρισμένο: η Roblox προειδοποιεί ότι ο χαρακτήρας κολλάει στη θέση του αν κρατά tool με anchored parts. Κάνει και ένα Tool που έχετε ήδη, αν το όνομά του ταιριάζει με τον κατάλογο από το βήμα 2.
  3. Προσθέτετε τα scripts καθώς προχωράτε στα βήματα. Το δέντρο δείχνει πού πηγαίνει το καθένα.
Το Explorer όταν τελειώσει ο οδηγός
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

Βήμα 2: περιγράψτε τα αντικείμενα στον κατάλογο

Ο κατάλογος περιγράφει μία φορά κάθε αντικείμενο που μπορεί να υπάρξει. Τα inventories μετά κρατούν μόνο το id του αντικειμένου και την ποσότητα. Έτσι οι αποθηκεύσεις μένουν μικρές, και αργότερα μπορείτε να μετονομάσετε ένα αντικείμενο ή να ξαναγράψετε την περιγραφή του χωρίς να αγγίξετε τα αποθηκευμένα δεδομένα κανενός.

Βάλτε ένα ModuleScript στο ReplicatedStorage, ονομάστε το ItemCatalog και αντικαταστήστε το περιεχόμενό του με αυτό:

ModuleScript στο ReplicatedStorage με όνομα ItemCatalog
-- Όλα τα αντικείμενα που μπορεί να υπάρχουν στο παιχνίδι. Αυτή τη λίστα τη διαβάζουν ο server και όλοι
-- οι clients· μόνο ο server αποφασίζει ποιος έχει τι.
export type Item = {
	id: string, -- πρέπει να ταιριάζει με το key παρακάτω
	name: string,
	description: string,
	maxStack: number, -- πόσα από αυτό το αντικείμενο χωρούν σε ένα slot
	icon: string?, -- προαιρετική εικόνα: "rbxassetid://" συν το ID της εικόνας σας
	toolName: string?, -- Tool στο ServerStorage.ItemTools: το αντικείμενο μπορεί να εξοπλιστεί
	heal: number?, -- πόση υγεία επαναφέρει: το αντικείμενο είναι αναλώσιμο
}

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

-- Επιστρέφει το αντικείμενο με αυτό το id ή nil αν δεν υπάρχει τέτοιο αντικείμενο
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Τα προαιρετικά πεδία αποφασίζουν τι κάνει το αντικείμενο. Το toolName το κάνει εξοπλίσιμο, το heal το κάνει χρησιμοποιήσιμο, και ένα αντικείμενο χωρίς κανένα από τα δύο, όπως το ξύλο, μένει στο inventory μέχρι να το αφαιρέσει άλλος κώδικας server (crafting, πώληση).

Για να προσθέσετε αντικείμενο, προσθέστε μια εγγραφή της οποίας το key και το id ταιριάζουν. Τα id κάνουν διάκριση πεζών και κεφαλαίων και είναι αυτά που αποθηκεύονται, οπότε μην αλλάζετε ποτέ ένα id όταν οι παίκτες έχουν ήδη το αντικείμενο: αλλάξτε το name του.

Βήμα 3: κρατήστε τα inventories στον server

Αυτό το ModuleScript έχει στην κατοχή του το inventory κάθε παίκτη. Κάθε inventory είναι μια λίστα από slots, σε κάθε slot ένα id αντικειμένου και μια ποσότητα, συν χωρητικότητα 20 slots. Τα άλλα server scripts καλούν τις συναρτήσεις του, και κανείς άλλος δεν επεξεργάζεται το table.

Βάλτε ένα ModuleScript στο ServerScriptService και ονομάστε το InventoryService:

ModuleScript στο ServerScriptService με όνομα InventoryService
-- Ο μόνος κώδικας που αλλάζει inventories. Βρίσκεται στο ServerScriptService,
-- όπου οι clients ούτε να τον δουν ούτε να τον τρέξουν μπορούν.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Η λειτουργία strict δεν βλέπει τι επιστρέφει ένα require μέσω WaitForChild, οπότε
-- περιγράφουμε το κομμάτι του module που χρησιμοποιεί αυτό το 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 -- slots ανά παίκτη
local STARTER_ITEMS: { Slot } = { -- με τι ξεκινά ένας εντελώς νέος παίκτης
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Στέλνει στον κάτοχο αντίγραφο του inventory του. Καλείται μετά από κάθε αλλαγή.
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

-- Κανόνες stacks: πρώτα γεμίζουμε τα μισογεμάτα stacks, μετά ξεκινάμε νέα stacks
-- σε κενά slots. Επιστρέφει πόσα προστέθηκαν, που μπορεί να είναι λιγότερα από όσα ζητήθηκαν.
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

-- Πόσα ακόμη από το αντικείμενο χωρούν: χώρος στα stacks του συν κενά slots
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

-- Προσθέτει έως amount κομμάτια από το αντικείμενο. Επιστρέφει πόσα προστέθηκαν (0 αν
-- το αντικείμενο δεν υπάρχει, το inventory είναι γεμάτο ή δεν έχει φορτώσει ακόμη).
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

-- Αφαιρεί ακριβώς amount κομμάτια από το αντικείμενο, ξεκινώντας από τα τελευταία stacks.
-- Αν ο παίκτης έχει λιγότερα, δεν αφαιρεί τίποτα και επιστρέφει 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
	-- Πηγαίνουμε από το τέλος, ώστε το table.remove να μην πηδά slots
	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

-- Καλείται όταν φόρτωσαν τα αποθηκευμένα δεδομένα του παίκτη. Το saved είναι ό,τι
-- επέστρεψε το data store: nil για νέο παίκτη. Κάθε εγγραφή περνά ξανά από τους
-- κανόνες stacks, οπότε διαγραμμένα αντικείμενα και παλιά μεγέθη stacks δεν χαλάνε τίποτα.
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

-- Απλό αντίγραφο για αποθήκευση ή nil αν τα δεδομένα του παίκτη δεν φόρτωσαν ποτέ
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

Οι γραμμές type και το cast :: μετά το require χρειάζονται μόνο για τον typechecker του Luau, που δεν βλέπει τι επιστρέφει ένα module που βρέθηκε μέσω WaitForChild. Κατά το παιχνίδι δεν αλλάζουν τίποτα. Τα υπόλοιπα scripts αυτού του οδηγού κάνουν το ίδιο.

Πώς δουλεύουν οι κανόνες stacks με τον κατάλογο πιο πάνω, όπου τα μήλα κάνουν stack έως 10:

  • Αν προσθέσετε 15 μήλα σε παίκτη με stack 7, αυτό το stack γεμίζει έως το 10 και μετά ξεκινά νέο stack με 5.
  • Όταν τελειώσουν τα slots, το add προσθέτει ό,τι χωρά και επιστρέφει αυτόν τον αριθμό. Καλέστε πρώτα το spaceFor όταν χρειάζεστε όλα ή τίποτα, όπως κάνει το μάζεμα στο βήμα 5.
  • Το remove δουλεύει με την αρχή όλα ή τίποτα. Ένα αίτημα για 3 μήλα σε παίκτη που έχει 2 δεν αφαιρεί τίποτα και επιστρέφει false, οπότε ελέγχετε το αποτέλεσμα πριν δώσετε κάτι σε αντάλλαγμα.
  • Στα slots δεν υπάρχουν κενά: όταν ένα slot αδειάζει, τα υπόλοιπα μετακινούνται προς τα πάνω. Έτσι η λίστα στέλνεται και αποθηκεύεται πιο εύκολα. Για slots που κρατούν τη θέση τους, δείτε τις ερωτήσεις στο τέλος.
Τι μπορούν να καλούν τα άλλα server scripts
ΣυνάρτησηΕπιστρέφειΓια τι
add(player, itemId, amount)Πόσα προστέθηκανΜάζεμα, ανταμοιβές, αγορές
remove(player, itemId, amount)true αν αφαιρέθηκαν όλαΧρήση, πώληση, crafting
count(player, itemId)Το σύνολο σε όλα τα stacksΈλεγχος του τι έχει ο παίκτης
spaceFor(player, itemId)Πόσα ακόμη χωρούνΈλεγχος πριν από προσθήκη με την αρχή όλα ή τίποτα
getEquipped, setEquippedΤο id του εξοπλισμένου αντικειμένου ή nilΕξοπλισμός, στο βήμα 6
load, serialize, unloadΑντίγραφο έτοιμο για αποθήκευση (serialize)Φόρτωση και αποθήκευση, στο βήμα 4

Βήμα 4: φορτώστε και αποθηκεύστε κάθε inventory

Τα inventories ζουν στη μνήμη του server, οπότε εξαφανίζονται όταν ο παίκτης φεύγει. Αυτό το script φορτώνει τα slots του παίκτη από το data store όταν μπαίνει, και τα γράφει πίσω όταν φεύγει, όταν κλείνει ο server και κάθε τρία λεπτά για την περίπτωση που ο server κρασάρει. Αποθηκεύει μόνο τα id των αντικειμένων και την ποσότητα: τα data stores δεν μπορούν να κρατήσουν Instance, όπως ένα Tool.

Βάλτε ένα Script στο ServerScriptService και ονομάστε το InventoryData:

Script στο ServerScriptService με όνομα 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

-- Αποθηκεύονται μόνο οι παίκτες των οποίων τα δεδομένα φόρτωσαν. Μετά από αποτυχημένη φόρτωση
-- δεν επιτρέπεται αποθήκευση, αλλιώς ένα κενό inventory θα αντικαταστήσει το πραγματικό.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Ένα αποτυχημένο αίτημα δεν πρέπει να κοστίσει σε κανέναν αντικείμενα, οπότε δοκιμάζουμε μερικές φορές.
-- Και το GetDataStore είναι μέσα σε pcall, οπότε μια συνεδρία Studio χωρίς πρόσβαση στα data
-- stores παίρνει προειδοποίηση αντί να σταματήσει αυτό το 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 -- ο παίκτης έφυγε ενώ φορτώναμε
	end
	if ok then
		InventoryService.load(player, saved) -- το saved είναι nil για νέο παίκτη
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Συνήθως σημαίνει ότι η πρόσβαση του Studio στα API services είναι απενεργοποιημένη. Παίζουμε με
		-- τα αρχικά αντικείμενα για να μπορείτε να δοκιμάζετε, αλλά δεν τα αποθηκεύουμε ποτέ.
		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 -- τα δεδομένα δεν φόρτωσαν ποτέ, δεν υπάρχει τίποτα να γραφτεί με ασφάλεια
	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)

-- Όταν κλείνει ο server, αποθηκεύουμε όλους όσοι είναι ακόμη εδώ και περιμένουμε κάθε
-- αποθήκευση που τρέχει, και όσες ξεκίνησε το PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Αποθηκεύουμε όλους κάθε λίγα λεπτά, ώστε ένα κρασάρισμα του server να κοστίζει λεπτά και όχι όλη τη συνεδρία
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Τι κάνει το script και γιατί:

  • Φόρτωση με προεπιλεγμένες τιμές. Ένας νέος παίκτης δεν έχει αποθηκευμένη τιμή, οπότε το GetAsync επιστρέφει nil, και παίρνει τα αρχικά αντικείμενα. Τα αποθηκευμένα slots περνούν ξανά από τους κανόνες stacks, οπότε ένα αντικείμενο που αφαιρέθηκε από τον κατάλογο ή ένα μικρότερο μέγιστο stack δεν θα χαλάσουν τη φόρτωση. Ό,τι δεν χωρά πια ή του οποίου το id δεν υπάρχει πια στον κατάλογο απορρίπτεται, και η επόμενη αποθήκευση το κάνει οριστικό, οπότε κρατήστε στον κατάλογο κάθε id που μπορεί να έχουν οι παίκτες.
  • Ποτέ αποθήκευση μετά από αποτυχημένη φόρτωση. Γράφονται μόνο οι παίκτες στο canSave. Σε ζωντανό server, ένας παίκτης του οποίου τα δεδομένα δεν φόρτωσαν ούτε μετά από τρεις προσπάθειες καλείται να ξαναμπεί. Στο Studio παίρνει αντί γι' αυτό αρχικά αντικείμενα που δεν αποθηκεύονται, μερικά δευτερόλεπτα αργότερα λόγω των επαναλήψεων. Έτσι θα είναι μέχρι να δημοσιευτεί το place με ενεργή την πρόσβαση στο API.
  • Αποθήκευση στην έξοδο και στο κλείσιμο. Το BindToClose αποθηκεύει όλους όσοι είναι ακόμη στον server και περιμένει τις αποθηκεύσεις που τρέχουν ήδη. Η Roblox δίνει στις συνδεδεμένες συναρτήσεις έως 30 δευτερόλεπτα.
  • Μέσα στα όρια. Μία εγγραφή ανά παίκτη κάθε τρία λεπτά συν μία στην έξοδο είναι πολύ λιγότερο από τον τυπικό προϋπολογισμό του server των 60 εγγραφών το λεπτό συν 40 για κάθε παίκτη (σύμφωνα με την τεκμηρίωση στις 30 Σεπτεμβρίου 2026). Το μοτίβο key User_ προέρχεται από τις συστάσεις της Roblox, και η μετάδοση του user ID στο SetAsync συνδέει τα δεδομένα με αυτόν τον παίκτη, κάτι που η Roblox συνιστά έντονα για τον χειρισμό αιτημάτων διαγραφής δεδομένων.

Για ένα μικρό παιχνίδι αυτή είναι μια αξιόπιστη βάση. Το session locking, που δεν αφήνει έναν παίκτη που άλλαξε γρήγορα server να φορτώσει τα δεδομένα πριν τα αποθηκεύσει ο παλιός server, και το πότε να χρησιμοποιείτε UpdateAsync αντί για SetAsync, εξηγούνται στο tutorial για το DataStore.

Βήμα 5: δώστε αντικείμενα από τον κόσμο

Το μάζεμα είναι ο πιο απλός τρόπος με τον οποίο μπαίνουν αντικείμενα στο inventory: ένα part με ProximityPrompt που προσθέτει το αντικείμενο όταν ο παίκτης το χρησιμοποιεί. Το script ακούει το event Triggered στον server, οπότε το αντικείμενο προστίθεται εκεί όπου ο client δεν μπορεί να παρέμβει.

  1. Προσθέστε ένα Part στο Workspace, ονομάστε το Apple και βάψτε το κόκκινο. Ενεργοποιήστε το Anchored και απενεργοποιήστε το CanCollide, ώστε κανείς να μην πέφτει πάνω του όσο είναι αόρατο. Το prompt δείχνει το όνομα του part.
  2. Με το part επιλεγμένο, κυλήστε το παράθυρο Properties ως την ενότητα Attributes και πατήστε +. Προσθέστε ItemId τύπου string και πατήστε Save, μετά ορίστε την τιμή apple. Με τον ίδιο τρόπο προσθέστε Amount τύπου number με τιμή 1.
  3. Βάλτε ένα Script στο part, ονομάστε το ItemPickup και επικολλήστε αυτόν τον κώδικα:
Script στο το part Apple στο Workspace με όνομα ItemPickup
-- Βάλτε αυτό το Script μέσα σε ένα Part και δώστε στο Part δύο attributes:
-- ItemId (string, για παράδειγμα apple) και Amount (αριθμός, για παράδειγμα 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 -- κάποιος άλλος το μάζεψε μόλις τώρα
	end
	-- Ελέγχουμε την απόσταση στον server, αντί να εμπιστευτούμε το αίτημα
	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 -- δεν υπάρχει χώρος: αφήνουμε το αντικείμενο στη θέση του
	end
	InventoryService.add(player, itemId, amount)

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

Αντιγράψτε το part για να βάλετε περισσότερα αντικείμενα. Αλλάξτε τα attributes για να δίνετε ξύλο, ένα ακόμη σπαθί ή ένα stack μήλων.

Η Roblox ελέγχει την απόσταση για το Triggered, αλλά ο οδηγός ασφαλείας της λέει παρ' όλα αυτά να ελέγχετε τα prompts στον server: ένας cheater μπορεί να ενεργοποιεί τα events του prompt ακόμη και όταν το Enabled είναι false, και μπορεί να τραβήξει ένα part χωρίς anchor προς τον χαρακτήρα του. Γι' αυτό το script ελέγχει μόνο του το Enabled και την απόσταση, και γι' αυτό το part είναι anchored.

Κάθε άλλο server script δίνει αντικείμενα με τον ίδιο τρόπο. Μετά από αγορά, quest ή kill φορτώστε το InventoryService με require, όπως τα scripts πιο πάνω, και καλέστε InventoryService.add(player, "wood", 5). Ελέγξτε πρώτα το spaceFor όταν το αντικείμενο δεν πρέπει να χαθεί. Άλλη μια πηγή μπορεί να είναι ένα NPC: στον οδηγό για διαλόγους με NPC μια απάντηση ενεργοποιεί μια ενέργεια στον server, και αυτή η ενέργεια μπορεί επίσης να καλέσει το InventoryService.add.

Βήμα 6: εξοπλισμός Tool και χρήση αντικειμένων

Δύο RemoteEvent μεταφέρουν τα μόνα αιτήματα που μπορεί να κάνει ο client. Το EquipItem βάζει ένα αντίγραφο του Tool του αντικειμένου από το ServerStorage στο Backpack του παίκτη (το hotbar στο κάτω μέρος της οθόνης) και στο χέρι του, και ένα δεύτερο αίτημα το βγάζει. Το UseItem αφαιρεί ένα κομμάτι από ένα χρησιμοποιήσιμο αντικείμενο και εφαρμόζει το εφέ του, εδώ θεραπεία.

Βάλτε ένα Script στο ServerScriptService και ονομάστε το InventoryActions:

Script στο ServerScriptService με όνομα 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 } = {}

-- Κάθε αίτημα ξεκινά εδώ. Ο client μπορεί να στείλει οτιδήποτε οποτεδήποτε, οπότε
-- ελέγχουμε τον τύπο, ότι το αντικείμενο υπάρχει, ότι το έχει ο παίκτης, και τη συχνότητα.
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

-- Καταστρέφει το Tool αυτού του αντικειμένου όπου κι αν είναι το αντίγραφο: hotbar, χέρι ή 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) -- ένα εξοπλισμένο tool τη φορά

	local tool = template:Clone()
	tool.CanBeDropped = false -- ένα αντίγραφο που πετάχτηκε θα μπορούσε να το σηκώσει κάποιος άλλος
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Ένα δεύτερο αντίγραφο στο StarterGear αντιγράφεται πίσω στο Backpack μετά το 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) -- κατευθείαν στο χέρι
	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) -- ένα δεύτερο κλικ σε εξοπλισμένο αντικείμενο το βγάζει
	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 -- νεκρός ή ήδη με πλήρη υγεία: δεν ξοδεύουμε το αντικείμενο
	end
	-- Πρώτα παίρνουμε το αντικείμενο, και θεραπεύουμε μόνο αν αυτό πέτυχε
	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)
Τι επιτρέπεται σε κάθε αίτημα
ΑίτημαΟ client στέλνειΟ server ελέγχει πριν από την ενέργεια
EquipItemId αντικειμένουΕίναι string, το αντικείμενο υπάρχει, ο παίκτης το έχει, τα αιτήματα έρχονται το πολύ τέσσερα το δευτερόλεπτο, το αντικείμενο έχει toolName, και ένα Tool με αυτό το όνομα βρίσκεται στο ServerStorage.ItemTools
UseItemId αντικειμένουΟι ίδιοι έλεγχοι τύπου, κατοχής και συχνότητας, το αντικείμενο έχει τιμή heal, ο χαρακτήρας είναι ζωντανός και τραυματισμένος, και ένα αντικείμενο αφαιρείται πριν προστεθεί υγεία

Τρεις λεπτομέρειες δεν αφήνουν το Tool να διπλασιαστεί ή να χαθεί. Στο αντίγραφο το CanBeDropped είναι false, επειδή ένα Tool που πετάχτηκε πέφτει στο Workspace, όπου μπορεί να το πάρει άλλος παίκτης, ενώ το πρωτότυπο μένει στο inventory. Κάθε αντίγραφο φέρει το attribute InventoryItem, οπότε στο βγάλσιμο μπορείτε να βρείτε και να καταστρέψετε κάθε αντίγραφο όπου κι αν είναι. Και αν ο παίκτης έχει container StarterGear, μπαίνει εκεί ένα δεύτερο αντίγραφο. Η Roblox αντιγράφει το StarterGear στο Backpack κάθε φορά που εμφανίζεται ο χαρακτήρας, οπότε το εξοπλισμένο σπαθί επιστρέφει μετά το respawn.

Μόνο ένα Tool είναι εξοπλισμένο τη φορά, και ο εξοπλισμός δεν αποθηκεύεται, οπότε μετά από επανείσοδο ο παίκτης ξεκινά με άδειο hotbar. Αν αργότερα προσθέσετε πώληση ή πέταγμα, βγάλτε το αντικείμενο πριν το τελευταίο του αντίγραφο φύγει από το inventory.

Το σπαθί placeholder μπορείτε να το κάνετε σπαθί που πολεμά στ' αλήθεια: φτιάξτε το Tool με τον οδηγό για το σπαθί, κρατήστε του το όνομα Sword και βάλτε το στο ItemTools στη θέση του placeholder. Το server script εκείνου του οδηγού θα ελέγχει κάθε χτύπημα, όπως κι αν πήρε ο παίκτης το σπαθί.

Βήμα 7: σχεδιάστε το πλέγμα του inventory

Το LocalScript φτιάχνει όλο το παράθυρο σε κώδικα, οπότε δεν χρειάζεται να στήσετε τίποτα με το χέρι. Το ScrollingFrame κρατά τα slots, το UIGridLayout μέσα του τα βάζει σε σειρές, και το AutomaticCanvasSize μεγαλώνει την περιοχή κύλισης όσο προστίθενται σειρές.

Στο Explorer ανοίξτε το StarterPlayer, βάλτε ένα LocalScript στο StarterPlayerScripts και ονομάστε το InventoryClient:

LocalScript στο StarterPlayerScripts με όνομα 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. Φτιάχνουμε το παράθυρο μία φορά. Το ResetOnSpawn = false το κρατά μετά τα respawns.
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 το μεγαλώνει για τα κελιά
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. Ένα κελί ανά slot. Αυτό μόνο σχεδιάζει ό,τι έστειλε ο server· το ίδιο
-- το inventory δεν αλλάζει ποτέ από εδώ.
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
	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()
		-- Ζητάμε, δεν διατάζουμε: ο server ελέγχει το αίτημα και στέλνει το αποτέλεσμα
		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

-- Ο server το στέλνει μετά τη φόρτωση και μετά από κάθε αλλαγή
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Άνοιγμα και κλείσιμο με κουμπί ή με το πλήκτρο B
local function toggle()
	panel.Visible = not panel.Visible
end

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

Ένα LocalScript στο StarterPlayerScripts τρέχει μία φορά ανά συνεδρία, και το ResetOnSpawn = false κρατά το ScreenGui στο respawn του χαρακτήρα, οπότε το πλέγμα συνεχίζει να δείχνει το τελευταίο αντίγραφο που έστειλε ο server.

Ο client σχεδιάζει ένα κελί για κάθε slot, και για τα κενά, οπότε ένα inventory 20 slots μοιάζει πάντα με 20 slots. Κάθε ενημέρωση καταστρέφει τα παλιά κελιά και φτιάχνει νέα, που είναι απλό και ταιριάζει για μερικές δεκάδες slots. Αν ο server στείλει το InventoryUpdated πριν συνδεθεί σε αυτό το script, η Roblox βάζει το μήνυμα σε ουρά και το παραδίδει μόλις συνδεθεί ο handler, οπότε το πρώτο inventory δεν χάνεται.

Θέλετε να σχεδιάσετε το παράθυρο στο Studio; Φτιάξτε ένα ScreenGui με ένα slot πρότυπο και κάντε του Clone στο makeCell. Για εικονίδια δώστε στο αντικείμενο του καταλόγου ένα icon με εικόνα που ανεβάσατε, και το κελί του θα δείχνει την εικόνα αντί για το όνομα.

Δοκιμάστε το inventory

  1. Πατήστε Play. Ανοίξτε το inventory με το κουμπί αριστερά ή με το πλήκτρο B: ένας νέος παίκτης έχει Sword και 3 Apple, και ο μετρητής δείχνει 2 / 20 slots. Όσο το Studio δεν μπορεί να χρησιμοποιήσει data stores, τα αντικείμενα εμφανίζονται μετά από μερικά δευτερόλεπτα, μετά από προειδοποιήσεις φόρτωσης στο Output, και δεν αποθηκεύονται.
  2. Κάντε κλικ στο Sword. Το σπαθί εμφανίζεται στο χέρι σας και στο hotbar, και το slot του παίρνει μωβ περίγραμμα. Κάντε ξανά κλικ για να το βγάλετε.
  3. Πηγαίνετε στο part Apple και χρησιμοποιήστε το prompt του. Το stack μήλων μεγαλώνει σε 4, και το part εξαφανίζεται για 15 δευτερόλεπτα.
  4. Για να δοκιμάσετε τη θεραπεία, μειώστε πρώτα την υγεία. Γυρίστε το Client/Server σε Server, επιλέξτε το Humanoid του χαρακτήρα σας στο Explorer, βάλτε το Health στο 50, γυρίστε πίσω σε Client και κάντε κλικ στο Apple.
  5. Με ενεργή την πρόσβαση του Studio στα API services, σταματήστε το παιχνίδι και ξεκινήστε το ξανά. Το μήλο που μαζέψατε είναι εκεί. Αν η φόρτωση ή η αποθήκευση απέτυχαν, θα το πει το Output.

Για δοκιμή με πολλούς παίκτες, επιλέξτε στις ρυθμίσεις δοκιμής Server & Clients με 2 clients. Κάθε παίκτης βλέπει μόνο το δικό του inventory, ενώ το σπαθί στο χέρι του άλλου το βλέπουν και οι δύο.

Συνηθισμένα λάθη και λύσεις

Τα περισσότερα προβλήματα φαίνονται στο παράθυρο Output ως προειδοποίηση ή κόκκινη γραμμή σφάλματος. Διαβάστε την πρώτη: τα επόμενα σφάλματα συχνά προκύπτουν από αυτήν.

Infinite yield possible σε κλήση WaitForChild

Το script περιμένει ένα αντικείμενο που δεν υπάρχει με ακριβώς αυτό το όνομα. Συγκρίνετε το Explorer σας με το δέντρο από το βήμα 1: InventoryRemotes με τρία RemoteEvent στο ReplicatedStorage, ItemTools στο ServerStorage και τα δύο modules. Τα ονόματα κάνουν διάκριση πεζών και κεφαλαίων. Ο οδηγός για σφάλματα scripts εξετάζει αυτή την προειδοποίηση πιο αναλυτικά.

Το πλέγμα ανοίγει, αλλά μένει άδειο

Ο client σχεδιάζει μόνο ό,τι στέλνει ο server. Ψάξτε στο Output για προειδοποιήσεις Inventory load failed και ελέγξτε ότι το InventoryData είναι Script, όχι LocalScript, στο ServerScriptService, και δίπλα του βρίσκεται το ModuleScript InventoryService. Αν το Output δείχνει σφάλμα Remote event invocation, κανείς στον client δεν ακούει το InventoryUpdated: ψάξτε ένα προηγούμενο σφάλμα από το InventoryClient.

Τα αντικείμενα μηδενίζονται κάθε φορά που παίζω στο Studio

Αν το Output γράφει Inventory not loaded: playing with starter items that will not be saved, το place δεν έχει δημοσιευτεί ή η πρόσβαση του Studio στα API services είναι απενεργοποιημένη. Ενεργοποιήστε την όπως περιγράφεται στο βήμα 4, σε δοκιμαστικό αντίγραφο του παιχνιδιού σας.

Το κλικ στο σπαθί δεν κάνει τίποτα

Ψάξτε στο Output για Cannot equip sword: το Tool στο ServerStorage.ItemTools πρέπει να λέγεται ακριβώς όπως το toolName στον κατάλογο. Επίσης το Tool χρειάζεται ένα part με όνομα Handle για να μπορεί να κρατηθεί, εκτός αν βάλατε το RequiresHandle του σε false.

Το prompt μαζέματος εμφανίζεται, αλλά δεν προστίθεται τίποτα

Το attribute ItemId πρέπει να ταιριάζει ακριβώς με το id του καταλόγου, μαζί με τα κεφαλαία: apple, όχι Apple. Τίποτα δεν προστίθεται όσο το inventory του παίκτη φορτώνει ακόμη ή όταν δεν υπάρχει χώρος για όλη την ποσότητα.

Η αποθήκευση χαλάει αφού άλλαξα τι αποθηκεύεται

Τα data stores δέχονται απλά δεδομένα: strings, αριθμούς, booleans και tables από αυτά. Η αποθήκευση ενός Tool, Part ή οποιουδήποτε άλλου Instance αποτυγχάνει, ή η τιμή αποθηκεύεται ως nil. Αποθηκεύστε το id του αντικειμένου και την ποσότητα, και όλα τα άλλα ξαναφτιάξτε τα από τον κατάλογο, όπως κάνει το serialize.

Φτιάξτε το με το RoCode

Αν σας είναι πιο εύκολο να περιγράψετε το σύστημα παρά να το στήσετε με το χέρι, το RoCode μπορεί να το φτιάξει στο place που έχετε ανοιχτό. Είναι ένας πράκτορας AI για το Roblox Studio: περιγράφετε τη λειτουργία στη συνομιλία στο web, και το plugin του για το Studio δημιουργεί τα scripts και τα αντικείμενα στο Explorer σας, αντί να σας δίνει κώδικα για επικόλληση.

Εσείς γράφετε

Πρόσθεσε inventory 20 slots με stacks αντικειμένων, πλέγμα UI που ανοίγει με το B, σπαθί από το ServerStorage που μπορούν να εξοπλίζουν οι παίκτες, μήλα που θεραπεύουν, και αποθήκευση μέσω DataStoreService.

Το RoCode κάνει
  • Μπορεί να εξετάσει το place σας όταν το χρειάζεται ένα βήμα, με Search Game και Search Scripts, ώστε να στηριχτεί σε αντικείμενα, remotes ή κώδικα αποθήκευσης που υπάρχουν ήδη και να μην προσθέσει δεύτερο σύστημα
  • Δημιουργεί φακέλους και RemoteEvent με Create Instance, και ModuleScript, Script και LocalScript με Create Script
  • Μπορεί να στήσει τον σκελετό του παραθύρου με Build UI, που περιέχει διάταξη inventory με slots placeholder· ο κώδικας που γεμίζει τα slots από τον server γράφεται σε ξεχωριστά scripts
  • Ελέγχει τη μεταγλώττιση κάθε script στο Studio με Check Script, που πιάνει σφάλματα μεταγλώττισης και μερικά ριψοκίνδυνα μοτίβα, αλλά δεν ελέγχει τύπους, δεν κάνει lint και δεν τρέχει τον κώδικά σας

Κάθε ομάδα αλλαγών είναι ένα σημείο αναίρεσης στο Studio. Το RoCode δεν μπορεί να ενεργοποιήσει την πρόσβαση του Studio στα API services, αυτό το κάνετε εσείς. Με plugin 3.9 ή νεότερο μπορεί να τρέξει ένα σύντομο playtest και να διαβάσει τα σφάλματα, και με plugin 3.9.15 ή νεότερο ο χαρακτήρας δοκιμών του μπορεί να πατά πλήκτρα και να εξοπλίζει αντικείμενα, αλλά ελέγχει μόνο ό,τι αποφάσισε ο ίδιος να δοκιμάσει, οπότε την αποθήκευση ελέγξτε τη μόνοι σας με playtest. Το inventory στέκεται πάνω σε άλλα συστήματα, όπως η αποθήκευση και τα tools, και ο κατασκευαστής παιχνιδιών με AI που χτίζει στο δικό σας place στο Studio τα προσθέτει ένα prompt κάθε φορά. Πώς συνδέεται το RoCode με το Studio.

Συχνές ερωτήσεις

Να χρησιμοποιήσω το Backpack του Roblox αντί για δικό μου inventory;

Το Backpack είναι το ενσωματωμένο inventory της Roblox: κάθε Tool μέσα του εμφανίζεται ως κουμπί στο hotbar. Αν όλα τα αντικείμενα στο παιχνίδι σας είναι Tools και δεν χρειάζεστε stacks, ποσότητες και όριο slots, μπορεί να αρκεί, αν και θα πρέπει πάλι να αποθηκεύετε ποια Tools έχει κάθε παίκτης. Δικό σας inventory χρειάζεται για αντικείμενα που δεν είναι Tools, όπως υλικά και αναλώσιμα. Αυτός ο οδηγός χρησιμοποιεί και τα δύο: το inventory κρατά τα πάντα και το Backpack κρατά το εξοπλισμένο Tool.

Πώς κρύβω το προεπιλεγμένο hotbar στο Roblox;

Από ένα LocalScript καλέστε StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Όταν το hotbar είναι κρυφό, οι παίκτες χρειάζονται άλλον τρόπο να πάρουν και να βγάλουν το εξοπλισμένο Tool, για παράδειγμα ένα κουμπί που ζητά από τον server να καλέσει Humanoid:EquipTool ή Humanoid:UnequipTools.

Πώς κάνω τα slots να κρατούν τη θέση τους για drag and drop;

Κρατήστε μια λίστα σταθερού μήκους με μία εγγραφή ανά slot και σημειώνετε τα κενά slots με μια τιμή όπως ένα κενό id, όχι με nil, επειδή η Roblox δεν συνιστά να στέλνετε tables με nil μέσω RemoteEvent. Μετά προσθέστε ένα RemoteEvent MoveItem που στέλνει δύο αριθμούς slots, και αφήστε τον server να ελέγχει ότι και οι δύο είναι ακέραιοι από 1 έως τη χωρητικότητα πριν τους αλλάξει θέση.

Πόσο μεγάλο μπορεί να είναι ένα αποθηκευμένο inventory;

Μία τιμή σε data store μπορεί να πιάνει έως 4 194 304 χαρακτήρες μετά το serialization (σύμφωνα με την τεκμηρίωση στις 30 Σεπτεμβρίου 2026). Μια λίστα από id και ποσότητες πιάνει ένα ελάχιστο κομμάτι από αυτό. Το μέγεθος της αποθήκευσης το μεγαλώνει το κείμενο ανά αντικείμενο, για παράδειγμα δικά σας ονόματα ή μεγάλες περιγραφές αποθηκευμένες για κάθε αντικείμενο.

Πώς αγοράζω και πουλάω αντικείμενα με coins;

Κάντε τα όλα στον server. Για πώληση, καλέστε InventoryService.remove και πληρώστε μόνο αν επέστρεψε true. Για αγορά, ελέγξτε την τιμή και το spaceFor, πάρτε τα coins και μετά καλέστε add. Ο οδηγός για το μαγαζί στήνει την πλευρά της αγοράς.

Πηγές και περαιτέρω ανάγνωση

Πώς ελέγχθηκε ο κώδικας: κάθε script σε αυτή τη σελίδα περνά αυστηρό έλεγχο τύπων Luau με τους ορισμούς του Roblox API (luau-lsp, 20 Νοεμβρίου 2026). Ο έλεγχος τύπων πιάνει λάθη σε ονόματα API και λάθος τύπους, όχι όμως λάθη στη λογική του παιχνιδιού, γι' αυτό δοκιμάστε τα πάντα στο Studio πριν τη δημοσίευση.

Δοκιμάστε το RoCode στο παιχνίδι σας.

Δωρεάν credits κάθε μέρα, χωρίς κάρτα. Εγκαταστήστε το plugin, περιγράψτε μια λειτουργία και δείτε τι εμφανίζεται στο Studio.