Tutoriel · Systèmes de jeu

Comment faire un système d'inventaire sur Roblox Studio

Un inventaire ressemble à un travail d'interface, mais ce qui décide si le tien peut être exploité, ou perdre des objets, c'est l'endroit où vivent les objets. Ce guide garde les objets de chaque joueur dans une table sur le serveur, envoie à chaque joueur une copie à dessiner sous forme de grille, le laisse équiper des Tools et utiliser des consommables par des requêtes que le serveur vérifie, et sauvegarde tout avec un data store.

Mis à jour le 14 novembre 202618 min de lectureÉcrit par

En bref

Garde les objets de chaque joueur dans une table sur le serveur, dans un ModuleScript dans ServerScriptService qui est le seul code autorisé à ajouter, retirer ou empiler des objets. Liste tes objets une seule fois dans un ModuleScript dans ReplicatedStorage (id, nom, taille de pile maximale). Après chaque changement, le serveur déclenche un RemoteEvent vers ce joueur avec une copie de son inventaire, et un LocalScript le dessine sous forme de grille avec un ScrollingFrame et un UIGridLayout.

  • Le client n'ajoute jamais d'objets. Il peut seulement demander, par exemple "équipe mon épée", et le serveur vérifie que le joueur en possède une avant d'agir.
  • Les objets n'arrivent que par du code serveur que tu contrôles : des objets à ramasser, des achats en boutique vérifiés par le serveur, des récompenses.
  • Sauvegarde les id et les quantités des objets, pas les Tools, avec DataStoreService quand les joueurs partent, quand le serveur s'arrête et toutes les quelques minutes. Ne sauvegarde jamais un joueur dont les données n'ont pas pu charger.
Sur cette page
  1. Fonctionnement
  2. Pourquoi le serveur garde les objets
  3. 1. Préparer l'Explorer
  4. 2. Catalogue d'objets
  5. 3. Inventaire serveur
  6. 4. Charger et sauvegarder
  7. 5. Objets à ramasser
  8. 6. Équiper et utiliser
  9. 7. Grille
  10. Tester
  11. Problèmes courants
  12. Avec RoCode
  13. Questions fréquentes
  14. Sources et lectures

Comment s'organise l'inventaire

Illustration animéeAppuie sur B, passe la souris sur un objet pour le lire, clique sur la Sword pour la tenir.

Le système est fait de six petites pièces, chacune avec un seul rôle. Toutes les règles sur les objets vivent dans un seul module côté serveur, donc quand quelque chose ne va pas, il y a exactement un endroit où chercher.

Les pièces et l'endroit où elles tournent
PièceType et emplacementRôle
ItemCatalogModuleScript dans ReplicatedStorageCe qu'est chaque objet : nom, description, taille de pile maximale, et s'il peut être équipé ou utilisé. Le serveur et chaque client le lisent.
InventoryServiceModuleScript dans ServerScriptServiceGarde les emplacements de chaque joueur. Le seul code qui ajoute, retire et empile des objets.
InventoryDataScript dans ServerScriptServiceCharge les objets d'un joueur quand il rejoint et les sauvegarde.
InventoryActionsScript dans ServerScriptServiceVérifie et exécute les requêtes pour équiper et utiliser.
ItemPickupScript dans une PartDonne un objet à celui qui le ramasse.
InventoryClientLocalScript dans StarterPlayerScriptsDessine la grille et envoie les requêtes. Il ne change rien lui-même.

Les données vont dans un seul sens. Le serveur modifie un inventaire, puis déclenche InventoryUpdated vers ce joueur avec tout l'inventaire, et le client redessine à partir de ça. Quand le joueur clique sur un emplacement, le client déclenche EquipItem ou UseItem avec l'id de l'objet ; le serveur vérifie la requête, fait le changement, et la nouvelle copie arrive par le même chemin. Envoyer tout l'inventaire est plus simple qu'envoyer les changements, et pour quelques dizaines d'emplacements le message reste petit.

Pourquoi le client n'ajoute jamais d'objets

C'est tentant d'ajouter un objet dans le LocalScript qui l'affiche : le joueur clique, l'emplacement se remplit. Ça casse de deux façons.

  • Personne d'autre ne le voit. Un changement fait dans un LocalScript n'existe que sur l'appareil de ce joueur. Le serveur n'en entend jamais parler, donc il n'est pas sauvegardé et aucun script serveur ne peut l'utiliser.
  • N'importe qui peut le truquer. Si tu règles ça avec un RemoteEvent comme AddItem(itemId, amount), un exploiteur peut déclencher cet événement lui-même, avec n'importe quels arguments, aussi souvent qu'il veut. Le guide de sécurité de Roblox dit que le serveur doit valider tout ce qu'un client envoie avant de l'utiliser.

Donc dans ce guide, le client peut seulement faire des requêtes sur des objets que le joueur possède déjà : "équipe ça" et "utilise ça". Chaque requête porte un seul id d'objet et aucune quantité, et passe une vérification sur le serveur : est-ce un string, est-ce un vrai objet, le joueur en possède-t-il au moins un, et le joueur envoie-t-il au plus quatre requêtes par seconde ? Le serveur cherche ensuite le Tool lui-même dans le catalogue. Il n'accepte jamais un Tool, un chemin ou une instance venant du client, ce contre quoi le même guide met en garde.

Les objets n'entrent que par du code serveur : un objet à ramasser que le serveur a vérifié, un achat que le serveur a fait payer (le guide de la boutique en construit un), une récompense de quête ou un butin. Pour le modèle RemoteEvent en général, avec la validation d'autres types d'arguments, lis le guide des RemoteEvents.

Étape 1 : préparer l'Explorer

Crée ces objets à la main. Les scripts des étapes suivantes les trouvent par leur nom, donc écris chaque nom exactement comme ici.

  1. Dans ReplicatedStorage, insère un Folder nommé InventoryRemotes. Dedans, insère trois RemoteEvents nommés InventoryUpdated, EquipItem et UseItem.
  2. Dans ServerStorage, insère un Folder nommé ItemTools. Dedans, insère un Tool nommé Sword, et dans le Tool une Part nommée Handle (1 sur 4 sur 1 studs suffit). Vérifie que la case Anchored du Handle est décochée : Roblox prévient que les personnages restent bloqués sur place quand ils tiennent un tool avec des parts ancrées. Un Tool que tu as déjà marche aussi, tant que son nom correspond au catalogue de l'étape 2.
  3. Ajoute les scripts au fur et à mesure des étapes. L'arbre montre où va chacun d'eux.
L'Explorer une fois le guide terminé
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

Étape 2 : lister tes objets dans un catalogue

Le catalogue décrit une seule fois chaque objet qui peut exister. Les inventaires ne stockent ensuite que l'id d'un objet et une quantité. Ça garde les sauvegardes petites, et tu peux renommer un objet ou réécrire sa description plus tard sans toucher aux données sauvegardées de personne.

Insère un ModuleScript dans ReplicatedStorage, nomme-le ItemCatalog et remplace son contenu par ceci :

ModuleScript dans ReplicatedStorage nommé ItemCatalog
-- Chaque objet qui peut exister dans le jeu. Le serveur et chaque client lisent cette
-- liste ; seul le serveur décide qui possède quoi.
export type Item = {
	id: string, -- doit correspondre à la clé ci-dessous
	name: string,
	description: string,
	maxStack: number, -- le maximum de cet objet qui tient dans un emplacement
	icon: string?, -- image facultative, écrite "rbxassetid://" suivi de l'ID de ton image
	toolName: string?, -- un Tool dans ServerStorage.ItemTools : l'objet peut être équipé
	heal: number?, -- vie rendue à l'utilisation : l'objet est un consommable
}

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

-- Renvoie l'objet avec cet id, ou nil si cet objet n'existe pas
function ItemCatalog.get(id: string): Item?
	return items[id]
end

return ItemCatalog

Les champs facultatifs décident de ce que fait un objet. toolName le rend équipable, heal le rend utilisable, et un objet qui n'a ni l'un ni l'autre, comme le bois, reste dans l'inventaire jusqu'à ce qu'un autre code serveur (artisanat, vente) le retire.

Pour ajouter un objet, ajoute une entrée dont la clé et l'id sont identiques. Les id tiennent compte des majuscules et ce sont eux qui sont sauvegardés, donc ne change jamais un id une fois que des joueurs possèdent l'objet : change plutôt son name.

Étape 3 : garder les inventaires sur le serveur

Ce ModuleScript possède l'inventaire de chaque joueur. Chaque inventaire est une liste d'emplacements, chaque emplacement un id d'objet et une quantité, plus une capacité de 20 emplacements. Les autres scripts serveur appellent ses fonctions, et rien d'autre ne modifie la table.

Insère un ModuleScript dans ServerScriptService et nomme-le InventoryService :

ModuleScript dans ServerScriptService nommé InventoryService
-- Le seul code qui modifie les inventaires. Il est dans ServerScriptService,
-- où les clients ne peuvent ni le voir ni le lancer.
local ReplicatedStorage = game:GetService("ReplicatedStorage")

-- Le mode strict ne peut pas suivre un require à travers WaitForChild, donc on décrit
-- la partie du module que ce script utilise
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 -- emplacements par joueur
local STARTER_ITEMS: { Slot } = { -- ce avec quoi un tout nouveau joueur commence
	{ id = "sword", count = 1 },
	{ id = "apple", count = 3 },
}

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

local InventoryService = {}

-- Envoie à son propriétaire une copie de son inventaire. Tourne après chaque changement.
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

-- Règles d'empilement : compléter les piles pas pleines, puis commencer de nouvelles piles dans
-- les emplacements vides. Renvoie combien ont été ajoutés, ce qui peut être moins que demandé.
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

-- Combien d'exemplaires d'un objet tiennent encore : la place dans ses piles plus les emplacements vides
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

-- Ajoute jusqu'à `amount` exemplaires d'un objet. Renvoie combien ont été ajoutés (0 si
-- l'objet n'existe pas, si l'inventaire est plein ou pas encore chargé).
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

-- Retire exactement `amount` exemplaires d'un objet, en prenant d'abord dans les dernières piles.
-- Si le joueur en a moins, ne retire rien et renvoie 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
	-- Parcourir à l'envers pour que table.remove ne saute jamais un emplacement
	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

-- Appelée une fois les données sauvegardées d'un joueur chargées. `saved` est ce que le data
-- store a renvoyé : nil pour un nouveau joueur. Chaque entrée repasse par les
-- règles d'empilement, donc les objets retirés et les anciennes tailles de pile ne cassent rien.
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

-- Une simple copie à sauvegarder, ou nil si les données de ce joueur n'ont jamais chargé
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

Les lignes type et le cast :: après require servent seulement au vérificateur de types de Luau, qui ne peut pas voir ce que renvoie un module trouvé avec WaitForChild. Elles ne changent rien quand le jeu tourne. Les autres scripts de ce guide font pareil.

Voici comment les règles d'empilement s'appliquent avec le catalogue ci-dessus, où les pommes s'empilent jusqu'à 10 :

  • Ajouter 15 pommes à un joueur qui a une pile de 7 remplit cette pile jusqu'à 10, puis commence une nouvelle pile de 5.
  • Quand il n'y a plus d'emplacements, add ajoute ce qui tient et renvoie ce nombre. Appelle d'abord spaceFor quand ça doit être tout ou rien, comme le fait l'objet à ramasser de l'étape 5.
  • remove fonctionne en tout ou rien. Demander 3 pommes à un joueur qui en a 2 n'en retire aucune et renvoie false, donc vérifie le résultat avant de donner quoi que ce soit en échange.
  • Les emplacements n'ont pas de trous : quand l'un se vide, les autres remontent. Ça garde la liste simple à envoyer et à sauvegarder. Les questions à la fin parlent des emplacements qui gardent leur position.
Ce que les autres scripts serveur peuvent appeler
FonctionRenvoieÀ utiliser pour
add(player, itemId, amount)Combien ont été ajoutésObjets à ramasser, récompenses, achats
remove(player, itemId, amount)true si tout a été retiréUtiliser, vendre, fabriquer
count(player, itemId)Le total sur toutes les pilesVérifier ce qu'un joueur possède
spaceFor(player, itemId)Combien tiendraient encoreVérifier avant un ajout en tout ou rien
getEquipped, setEquippedL'id de l'objet équipé, ou nilÉquiper, à l'étape 6
load, serialize, unloadUne copie prête à sauvegarder (serialize)Charger et sauvegarder, à l'étape 4

Étape 4 : charger et sauvegarder chaque inventaire

Les inventaires vivent dans la mémoire du serveur, donc ils disparaissent quand le joueur part. Ce script charge les emplacements d'un joueur depuis un data store quand il rejoint et les réécrit quand il part, quand le serveur s'arrête, et toutes les trois minutes au cas où le serveur planterait. Il ne sauvegarde que les id et les quantités : les data stores ne peuvent pas stocker d'Instances comme des Tools.

Insère un Script dans ServerScriptService et nomme-le InventoryData :

Script dans ServerScriptService nommé 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

-- Seuls les joueurs dont les données ont chargé sont sauvegardés. Un chargement raté ne doit
-- jamais être suivi d'une sauvegarde, sinon l'inventaire vide remplace le vrai.
local canSave: { [Player]: boolean } = {}
local activeSaves = 0

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

-- Une requête ratée ne doit faire perdre ses objets à personne, donc on réessaie quelques fois.
-- GetDataStore est aussi dans le pcall, pour qu'une session Studio qui ne peut pas
-- joindre les data stores reçoive un avertissement au lieu d'arrêter ce 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 -- il est parti pendant le chargement
	end
	if ok then
		InventoryService.load(player, saved) -- saved vaut nil pour un nouveau joueur
		canSave[player] = true
	elseif RunService:IsStudio() then
		-- Veut souvent dire que l'accès de Studio aux services API est désactivé. Jouer avec les
		-- objets de départ pour pouvoir tester, mais ne jamais les sauvegarder.
		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 -- ses données n'ont jamais chargé, donc rien ne peut être écrit sans risque
	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)

-- Quand le serveur s'arrête, sauvegarder tous ceux encore là, puis attendre chaque
-- sauvegarde en cours, y compris celles lancées par PlayerRemoving
game:BindToClose(function()
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
	while activeSaves > 0 do
		task.wait()
	end
end)

-- Sauvegarder tout le monde toutes les quelques minutes, pour qu'un crash coûte des minutes, pas une session
while true do
	task.wait(AUTOSAVE_SECONDS)
	for _, player in Players:GetPlayers() do
		task.spawn(save, player)
	end
end

Ce que fait le script, et pourquoi :

  • Charger avec des valeurs par défaut. Un nouveau joueur n'a aucune valeur sauvegardée, donc GetAsync renvoie nil et il reçoit les objets de départ. Les emplacements sauvegardés repassent par les règles d'empilement, donc un objet que tu as retiré du catalogue ou une taille de pile plus petite ne peut pas casser un chargement. Tout ce qui ne tient plus, ou dont l'id n'est plus dans le catalogue, est abandonné, et la sauvegarde suivante rend ça définitif, donc garde dans le catalogue chaque id que des joueurs peuvent posséder.
  • Ne jamais sauvegarder après un chargement raté. Seuls les joueurs dans canSave sont écrits. Sur un serveur en ligne, un joueur dont les données ne chargent toujours pas après trois essais est invité à revenir. Dans Studio, il reçoit à la place des objets de départ non sauvegardés, quelques secondes plus tard à cause des nouveaux essais, et c'est ce que tu vois tant que le jeu n'est pas publié avec l'accès aux API activé.
  • Sauvegarder au départ et à l'arrêt. BindToClose sauvegarde tous ceux encore sur le serveur et attend les sauvegardes déjà en cours. Roblox donne jusqu'à 30 secondes aux fonctions liées.
  • Rester dans les limites. Une écriture par joueur toutes les trois minutes, plus une quand il part, c'est très en dessous du budget par défaut par serveur de 60 écritures par minute plus 40 par joueur (selon la documentation au 30 septembre 2026). Le modèle de clé User_ suit les bonnes pratiques de Roblox, et passer l'ID utilisateur à SetAsync relie les données à ce joueur, ce que Roblox recommande fortement pour traiter les demandes de suppression de données.

C'est une base solide pour un petit jeu. Le verrouillage de session, qui empêche un joueur qui change vite de serveur de charger ses données avant que l'ancien serveur les ait sauvegardées, et quand utiliser UpdateAsync au lieu de SetAsync, sont expliqués dans le tutoriel DataStore.

Étape 5 : donner des objets depuis le monde

Un objet à ramasser est la façon la plus simple de faire entrer des objets dans un inventaire : une part avec un ProximityPrompt qui ajoute un objet quand un joueur l'utilise. Le script écoute son événement Triggered sur le serveur, donc l'objet est ajouté là où le client ne peut pas intervenir.

  1. Ajoute une Part dans Workspace, nomme-la Apple et colore-la en rouge. Coche Anchored et décoche CanCollide, pour que personne ne la heurte pendant qu'elle est invisible. Le prompt affiche le nom de la part.
  2. Avec la part sélectionnée, descends jusqu'à la section Attributes de la fenêtre Properties et clique sur +. Ajoute ItemId avec le type string et clique sur Save, puis règle sa valeur sur apple. Ajoute Amount de la même façon en number réglé sur 1.
  3. Insère un Script dans la part, nomme-le ItemPickup et colle ce code :
Script dans la part Apple de Workspace nommé ItemPickup
-- Mets ce Script dans une Part et donne à la Part deux attributs :
-- ItemId (un string, comme apple) et Amount (un number, comme 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 -- quelqu'un d'autre l'a ramassé il y a un instant
	end
	-- Vérifier la distance sur le serveur au lieu de faire confiance à la requête
	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 -- pas assez de place : laisser l'objet là où il est
	end
	InventoryService.add(player, itemId, amount)

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

Copie la part pour placer d'autres objets à ramasser. Change les attributs pour distribuer du bois, une autre épée ou une pile de pommes.

Roblox vérifie la distance pour Triggered, mais son guide de sécurité te dit quand même de valider les prompts sur le serveur : un exploiteur peut déclencher les événements d'un prompt même quand Enabled vaut false, et peut tirer une part non ancrée à côté de son personnage. C'est pour ça que le script vérifie Enabled et la distance lui-même, et que la part est ancrée.

N'importe quel autre script serveur donne des objets de la même façon. Après un achat, une quête ou un kill, fais un require de InventoryService comme les scripts ci-dessus et appelle InventoryService.add(player, "wood", 5). Vérifie d'abord spaceFor chaque fois que l'objet ne doit pas être perdu. Un PNJ peut être une autre source : dans le guide du dialogue de PNJ, une réponse lance une action sur le serveur, et cette action peut appeler InventoryService.add de la même façon.

Étape 6 : équiper des Tools et utiliser des objets

Deux RemoteEvents portent les seules requêtes qu'un client peut faire. EquipItem met une copie du Tool de l'objet depuis ServerStorage dans le Backpack du joueur (la barre d'objets en bas de l'écran) et dans sa main, et redemander la retire. UseItem retire un exemplaire d'un objet utilisable et applique son effet, ici un soin.

Insère un Script dans ServerScriptService et nomme-le InventoryActions :

Script dans ServerScriptService nommé 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 } = {}

-- Chaque requête commence ici. Un client peut envoyer n'importe quoi à tout moment, donc vérifier
-- le type, que l'objet existe, que le joueur en possède un, et la fréquence.
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

-- Détruit le Tool de cet objet partout où il y a une copie : barre d'objets, main ou 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 seul tool équipé à la fois

	local tool = template:Clone()
	tool.CanBeDropped = false -- une copie lâchée pourrait être ramassée par quelqu'un d'autre
	tool:SetAttribute("InventoryItem", item.id)
	tool.Parent = backpack

	-- Une deuxième copie dans StarterGear est recopiée dans le Backpack après une réapparition
	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) -- le mettre directement dans sa main
	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) -- recliquer sur l'objet équipé le range
	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 ou déjà à fond de vie : ne pas gaspiller l'objet
	end
	-- Prendre l'objet d'abord, et ne soigner que si ça a marché
	if InventoryService.remove(player, item.id, 1) then
		humanoid.Health = math.min(humanoid.MaxHealth, humanoid.Health + heal)
	end
end)

Players.PlayerRemoving:Connect(function(player: Player)
	lastRequest[player] = nil
end)
Ce que chaque requête a le droit de faire
RequêteLe client envoieLe serveur vérifie avant d'agir
EquipItemUn id d'objetC'est un string, l'objet existe, le joueur en possède un, les requêtes n'arrivent pas plus vite que quatre par seconde, l'objet a un toolName, et un Tool de ce nom est dans ServerStorage.ItemTools
UseItemUn id d'objetLes mêmes vérifications de type, de possession et de fréquence, l'objet a une valeur heal, le personnage est en vie et blessé, et un objet a été retiré avant de rendre de la vie

Trois détails empêchent un Tool d'être dupliqué ou perdu. La copie a CanBeDropped réglé sur false, parce qu'un Tool lâché atterrit dans Workspace, où un autre joueur pourrait le prendre pendant que l'original reste dans l'inventaire. Chaque copie porte un attribut InventoryItem, pour que le déséquipement puisse trouver et détruire chaque copie où qu'elle soit. Et quand le joueur a un conteneur StarterGear, une deuxième copie y va. Roblox copie StarterGear dans le Backpack à chaque apparition du personnage, donc une épée équipée revient après une réapparition.

Un seul Tool est équipé à la fois, et ce qui est équipé n'est pas sauvegardé, donc un joueur qui revient commence avec une barre d'objets vide. Si tu ajoutes plus tard la vente ou le lâcher d'objets, déséquipe un objet avant que sa dernière copie quitte l'inventaire.

L'épée provisoire peut devenir une épée qui se bat vraiment : construis le Tool du guide de l'épée, garde son nom Sword et mets-le dans ItemTools à la place de l'épée provisoire. Le script serveur de ce guide vérifie alors chaque coup, quelle que soit la façon dont le joueur a eu l'épée.

Étape 7 : dessiner la grille de l'inventaire

Le LocalScript construit toute la fenêtre en code, donc il n'y a pas d'interface à placer à la main. Un ScrollingFrame contient les emplacements, un UIGridLayout dedans les range en lignes, et AutomaticCanvasSize agrandit la zone de défilement quand des lignes s'ajoutent.

Dans l'Explorer, ouvre StarterPlayer, insère un LocalScript dans StarterPlayerScripts et nomme-le InventoryClient :

LocalScript dans StarterPlayerScripts nommé 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. Construire la fenêtre une fois. ResetOnSpawn = false la garde après les réapparitions.
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 l'agrandit pour contenir les cases
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. Une case par emplacement. Ça dessine seulement ce que le serveur a envoyé ; ça ne
-- modifie jamais l'inventaire.
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 -- un emplacement vide
	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()
		-- Demander, jamais imposer : le serveur vérifie la requête et renvoie le résultat
		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

-- Le serveur l'envoie après le chargement et après chaque changement
inventoryUpdated.OnClientEvent:Connect(render)

-- 3. Ouvrir et fermer avec le bouton ou la touche 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 dans StarterPlayerScripts tourne une fois par session, et ResetOnSpawn = false garde la ScreenGui quand le personnage réapparaît, donc la grille affiche toujours la dernière copie envoyée par le serveur.

Le client dessine une case pour chaque emplacement, vides compris, donc un inventaire de 20 emplacements ressemble toujours à 20 emplacements. Chaque mise à jour détruit les anciennes cases et en construit de nouvelles, ce qui est simple et suffit pour quelques dizaines d'emplacements. Si le serveur déclenche InventoryUpdated avant que ce script s'y soit connecté, Roblox met le message en file d'attente et le livre dès que le gestionnaire se connecte, donc le premier inventaire n'est pas perdu.

Tu préfères dessiner la fenêtre dans Studio ? Construis une ScreenGui avec un emplacement modèle et fais-en un Clone dans makeCell. Pour les icônes, règle l'icon d'un objet dans le catalogue sur une image que tu as importée, et sa case affiche l'image au lieu du nom.

Tester l'inventaire

  1. Appuie sur Play. Ouvre l'inventaire avec le bouton à gauche ou B : un nouveau joueur a une Sword et 3 Apples, et le compteur affiche 2 / 20 slots. Tant que Studio ne peut pas joindre les data stores, les objets mettent quelques secondes à apparaître, après des avertissements de chargement dans Output, et ne sont pas sauvegardés.
  2. Clique sur la Sword. Elle apparaît dans ta main et dans la barre d'objets, et son emplacement est entouré de violet. Clique encore dessus pour la ranger.
  3. Va jusqu'à la part Apple et utilise son prompt. La pile de pommes monte à 4, et la part disparaît pendant 15 secondes.
  4. Pour essayer le soin, baisse d'abord ta vie. Passe le bouton Client/Server sur Server, sélectionne le Humanoid de ton personnage dans l'Explorer, règle Health sur 50, repasse sur Client et clique sur une Apple.
  5. Avec l'accès de Studio aux services API activé, arrête et relance le jeu. La pomme que tu as ramassée est toujours là. Si un chargement ou une sauvegarde a échoué, Output le dit.

Pour le voir avec plus d'un joueur, choisis Server & Clients dans les options de test avec 2 clients. Chaque joueur ne voit que son propre inventaire, mais les deux peuvent voir une épée dans la main de l'autre.

Problèmes courants

La plupart des problèmes apparaissent dans la fenêtre Output sous forme d'avertissement ou de ligne d'erreur rouge. Lis la première : les erreurs suivantes en sont souvent la conséquence.

Infinite yield possible sur un appel à WaitForChild

Un script attend un objet qui n'existe pas sous ce nom exact. Compare ton Explorer avec l'arbre de l'étape 1 : InventoryRemotes avec ses trois RemoteEvents dans ReplicatedStorage, ItemTools dans ServerStorage, et les deux modules. Les noms tiennent compte des majuscules. Le guide des erreurs de script explique cet avertissement plus en détail.

La grille s'ouvre mais reste vide

Le client ne dessine que ce que le serveur envoie. Cherche dans Output des avertissements Inventory load failed, et vérifie que InventoryData est un Script, pas un LocalScript, dans ServerScriptService, avec le ModuleScript InventoryService à côté. Si Output affiche une erreur Remote event invocation, rien sur le client n'écoute InventoryUpdated : cherche une erreur plus ancienne venant de InventoryClient.

Les objets se réinitialisent à chaque fois que je joue dans Studio

Si Output affiche Inventory not loaded: playing with starter items that will not be saved, le jeu n'est pas publié ou l'accès de Studio aux services API est désactivé. Active-le comme expliqué à l'étape 4, dans une copie de test de ton jeu.

Cliquer sur l'épée ne fait rien

Cherche Cannot equip sword dans Output : le Tool dans ServerStorage.ItemTools doit avoir exactement le même nom que toolName dans le catalogue. Un Tool a aussi besoin d'une part nommée Handle pour être tenu, sauf si tu règles son RequiresHandle sur false.

Le prompt de l'objet à ramasser s'affiche, mais rien n'est ajouté

L'attribut ItemId doit correspondre exactement à un id du catalogue, majuscules comprises : apple, pas Apple. Rien n'est ajouté tant que l'inventaire du joueur charge encore, ou quand il n'y a pas assez de place pour toute la quantité.

La sauvegarde échoue depuis que j'ai changé ce qui est sauvegardé

Les data stores acceptent des données simples : strings, numbers, booleans et des tables de ces types. Sauvegarder un Tool, une Part ou n'importe quelle autre Instance échoue, ou la valeur est stockée comme nil. Sauvegarde l'id et la quantité de l'objet, et reconstruis tout le reste depuis le catalogue, comme le fait serialize.

Le faire avec RoCode

Si tu préfères décrire le système plutôt que le câbler à la main, RoCode peut le construire dans le jeu que tu as ouvert. C'est un agent IA pour Roblox Studio : tu décris la fonction dans un chat web, et son plugin pour Studio crée les scripts et les objets dans ton Explorer au lieu de te donner du code à coller.

Tu écris

Ajoute un inventaire de 20 emplacements qui empile les objets, une grille qui s'ouvre avec B, une épée dans ServerStorage que les joueurs peuvent équiper, des pommes qui soignent, et une sauvegarde avec DataStoreService.

RoCode fait
  • Peut parcourir ton jeu quand une étape le demande, avec Search Game et Search Scripts, pour s'appuyer sur les objets, les remotes ou le code de sauvegarde que tu as déjà au lieu d'ajouter un deuxième système
  • Crée les dossiers et les RemoteEvents avec Create Instance, et les ModuleScripts, les Scripts et le LocalScript avec Create Script
  • Peut préparer la fenêtre avec Build UI, qui a une mise en page d'inventaire avec des emplacements provisoires ; le code qui remplit les emplacements depuis le serveur est écrit dans des scripts séparés
  • Vérifie la compilation de chaque script dans Studio avec Check Script, qui repère les erreurs de compilation et quelques schémas risqués mais ne vérifie pas les types, ne fait pas de lint et ne lance pas ton code

Chaque lot de changements est un point d'annulation dans Studio. RoCode ne peut pas activer l'accès de Studio aux services API, donc tu le fais toi-même. Avec le plugin 3.9 ou plus récent, RoCode peut lancer un court test et lire les erreurs, et avec le plugin 3.9.15 ou plus récent son personnage de test peut appuyer sur des touches et équiper des objets, mais il ne vérifie que ce qu'il a choisi de tester, donc teste la sauvegarde toi-même. Un inventaire repose sur d'autres systèmes comme la sauvegarde et les tools, et un créateur de jeux IA qui construit dans ton propre jeu Studio les ajoute un prompt à la fois. Comment RoCode se connecte à Studio.

Questions fréquentes

Faut-il utiliser le Backpack de Roblox au lieu d'un inventaire personnalisé ?

Le Backpack est l'inventaire intégré de Roblox : chaque Tool dedans s'affiche comme un bouton dans la barre d'objets. Si tous les objets de ton jeu sont des Tools et que tu n'as besoin ni de piles, ni de quantités, ni de limite d'emplacements, il peut suffire, même s'il faut quand même sauvegarder quels Tools chaque joueur possède. Un inventaire personnalisé sert aux objets qui ne sont pas des Tools, comme les matériaux et les consommables. Ce guide utilise les deux : l'inventaire stocke tout, et le Backpack contient le Tool équipé.

Peut-on cacher la barre d'objets par défaut ?

Oui. Depuis un LocalScript, appelle StarterGui:SetCoreGuiEnabled(Enum.CoreGuiType.Backpack, false). Avec la barre cachée, les joueurs ont besoin d'un autre moyen de tenir et de ranger un Tool équipé, par exemple un bouton qui demande au serveur d'appeler Humanoid:EquipTool ou Humanoid:UnequipTools.

Comment faire pour que les emplacements gardent leur position pour le glisser-déposer ?

Stocke une liste de longueur fixe avec une entrée par emplacement, et marque les emplacements vides avec une valeur comme un id vide plutôt que nil, parce que Roblox déconseille les valeurs nil dans les tables envoyées par un RemoteEvent. Ajoute ensuite un RemoteEvent MoveItem qui envoie deux numéros d'emplacement, et fais vérifier au serveur que les deux sont des nombres entiers entre 1 et la capacité avant de les échanger.

Quelle taille peut atteindre un inventaire sauvegardé ?

Une valeur de data store peut faire jusqu'à 4 194 304 caractères une fois sérialisée (selon la documentation au 30 septembre 2026). Une liste d'id et de quantités en utilise une toute petite partie. Ce qui fait grossir une sauvegarde, c'est du texte par objet, comme des noms personnalisés ou de longues descriptions sauvegardés pour chaque objet.

Comment acheter ou vendre des objets contre des pièces ?

Fais tout sur le serveur. Pour vendre, appelle InventoryService.remove et ne paie que s'il a renvoyé true. Pour acheter, vérifie le prix et spaceFor, retire les pièces, puis appelle add. Le guide de la boutique construit la partie achat.

Sources et lectures

Comment le code a été vérifié : chaque script de cette page passe le vérificateur de types strict de Luau avec les définitions de l'API Roblox (luau-lsp, 14 novembre 2026). Une vérification de types repère les API mal écrites et les mauvais types, pas la logique du jeu : teste dans Studio avant de publier.

Essaie RoCode sur ton propre jeu.

Des crédits gratuits chaque jour, sans carte. Installe le plugin, décris la fonctionnalité et vérifie ce qui arrive dans Studio.